ae pessoal o codigo abaixo tanto faz sincronizado como nao… ele imprime a mesma coisa nao entendi entao a diferença e o uso de bloquear usando essa sintaxe…
class SynTest extends Thread{
public void Stuf(){
System.out.println("non");
//synchronized(this){
for(int x=0;x<2;x++){
System.out.println("num " + x +" " + Thread.currentThread().getName());
try{
Thread.sleep(500);
}catch(InterruptedException e){}
}
//}
}
public void run(){
Stuf();
}
public static void main(String args[]){
SynTest s = new SynTest();
SynTest s2 = new SynTest();
s.start();
s2.start();
}
}
somente uma thread foi executada…
non
num 0 Thread-0
num 1 Thread-0
resultado foi esse…
acabei de fazer esse para ver se entendo…
[code]
class Exe92 extends Thread{
public void run(){
synchronized(this){
for(int x=0;x<2;x++){
System.out.println(Thread.currentThread().getName());
System.out.println(“a”);
}
}
}
Exe92(StringBuffer z){}
public static void main(String args[]){
StringBuffer a = new StringBuffer("A");
Exe92 e = new Exe92(a);
Exe92 e2 = new Exe92(a);
e.start();
e2.start();
}
Você pode sincronizar trechos de código. A “sincronização de método” é uma forma prática de sincronizar o trecho de código de um método inteiro, de uma só vez, usando como objeto de sincronização o this.
non
num 0 Thread-0
non
num 1 Thread-0
num 0 Thread-1
num 1 Thread-1
Note que, como o bloco é sincronizado, a thread 0 usa a impressão do número e valor completamente, antes que a thread 1 possa iniciar.
Apenas o non da thread 1 aparece “no meio” da thread 0, isso porque a impressão da palavra non não está num bloco sincronizado. Logo, ambas as threads puderam acessa-lo.
Retirando a sincronização obtive:
non
num 0 Thread-0
non
num 0 Thread-1
num 1 Thread-0
num 1 Thread-1
Veja como agora a execução ficou totalmente misturada.
Não adianta fazer um loop maior, embora certamente algumas impressões a mais ajudem.
Novamente, no caso da classe bloco, você criou 2 objetos distintos, e cada thread vai acessar seu próprio objeto. Não haverá diferença entre sincronizar ou não.
No caso da classe que eu fiz, o objeto Writer é compartilhado pelas duas threads.
[quote=ViniGodoy]No código que eu fiz o resultado foi:
non
num 0 Thread-0
non
num 1 Thread-0
num 0 Thread-1
num 1 Thread-1
Note que, como o bloco é sincronizado, a thread 0 usa a impressão do número e valor completamente, antes que a thread 1 possa iniciar.
Apenas o non da thread 1 aparece “no meio” da thread 0, isso porque a impressão da palavra non não está num bloco sincronizado. Logo, ambas as threads puderam acessa-lo.
Retirando a sincronização obtive:
non
num 0 Thread-0
non
num 0 Thread-1
num 1 Thread-0
num 1 Thread-1
Veja como agora a execução ficou totalmente misturada.[/quote]
po vinny saquei valeu… rpz… isso eh uma noia viu? ave-maria… agora o codigo abaixo eh valido quando tenho extends Thread? posso dizer que ta acessando o mesmo objeto?
Exe92 e = new Exe92(a);
Exe92 e2 = new Exe92(a);
e.start();
e2.start();
Trechos de código apenas… apenas trechos de código…
Portanto, o modificador sincronized poderá ser usado para um método, para sincronizar todo o trecho de código no interior daquele método, mas não para uma variável.
O synchronized (variavel) {…} não está sincronizando a variável em si, mas o código que vem logo abaixo, entre chaves. É uma das formas de se sincronizar apenas uma parte de um método.
A variável naquele caso só indica o objeto que está sendo usado para o controle da sincronização. Quando uma Thread entra nesse trecho de código sincronizado ela “captura” esse objeto. Outras threads não poderão fazer o mesmo e terão que esperar.
Por isso no seu programa a sincronização não surtiu efeito. Como você tinha 2 objetos, cada thread pode capturar o seu próprio “this” e, portanto, tiveram acesso ao código sincronizado.