Veja a consequência de threads executando o mesmo objeto porém com locks em objetos diferentes

public class TestThread5 {

public static void main(String[] args) {

EmbaralhaPalavras e = new EmbaralhaPalavras(“Não entendo direito esse negócio de Thread. É um pouco abstrato !”);

// duas threads executando o mesmo objeto (e à EmbaralhaPalavras)

Thread t1 = new Thread(e, “T1”);

Thread t2 = new Thread(e, “T2”);

t1.start();

t2.start();

}

}

 
 

class EmbaralhaPalavras implements Runnable {

private String texto;

private String[] tokens;

 
 

// objetos declarados apenas para promover o lock

private Object lock1 = new Object();

private Object lock2 = new Object();

 
 

public EmbaralhaPalavras(String texto) {

this.texto = texto;

// Tokeniza

tokens = this.texto.split(” “);

}

 
 

public void demonstra1(){

synchronized (lock1) {

this.demonstra(” ** Método DEMONSTRA1 ** “);

}

}

 
 

public void demonstra2(){

synchronized (lock2) {

this.demonstra(” ** Método DEMONSTRA2 ** “);

}

}

 
 

public void demonstra(String metodo){

System.out.println();

System.out.println(Thread.currentThread().getName() + ” – ” + metodo);

for (String s : tokens) {

System.out.print(s + ” “);

try {

if (Thread.currentThread().getName().equals(“T1”))

Thread.sleep(500);

else

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

 
 

@Override

public void run() {

demonstra1();

demonstra2();

}

}

Possível output:

  1. T1 – ** Método DEMONSTRA1 **

    Não entendo direito esse negócio de Thread. É um pouco abstrato !

  2. T1 – ** Método DEMONSTRA2 **

    Não

  3. T2 – ** Método DEMONSTRA1 **

    Não entendo direito esse negócio
    entendo de Thread.
    É um pouco direito abstrato
    ! esse negócio de Thread. É um pouco abstrato !

  4. T2 – ** Método DEMONSTRA2 **

    Não entendo direito esse negócio de Thread. É um pouco abstrato !

 
 

 
 

Análise do resultado:

 
 

Na linha 1 inicia-se a execução do Método 1 pela Thread 1.

Na linha 2 assim que a Thread 1 começa a executar o Método 2, ela é interrompida e é iniciada a Thread 2 que começa executando o Método 1 .

Na linha 3 ocorre uma miscelânea na execução das threads devido ao objeto lock1 e lock2 que promovem a “trava” para os blocos sincronizados serem diferentes.

Na linha 4 apenas a Thread 2 executa o Método 2.

 
 

Ao passar como lock o mesmo objeto, o resultado sai ok:

 
 

public void demonstra1(){

synchronized (lock1) {

demonstra(” ** Método DEMONSTRA1 ** “);

}

}

 
 

public void demonstra2(){

synchronized (lock1) {

demonstra(” ** Método DEMONSTRA2 ** “);

}

}

 
 

Possível output:

T1 – ** Método DEMONSTRA1 **

Não entendo direito esse negócio de Thread. É um pouco abstrato !

T2 – ** Método DEMONSTRA1 **

Não entendo direito esse negócio de Thread. É um pouco abstrato !

T2 – ** Método DEMONSTRA2 **

Não entendo direito esse negócio de Thread. É um pouco abstrato !

T1 – ** Método DEMONSTRA2 **

Não entendo direito esse negócio de Thread. É um pouco abstrato !

 
 

 
 

Análise do resultado:

 
 

Podemos observar que ao passar o mesmo objeto para promover o lock na instrução synchronized, a execução das Threads ficam sincronizadas e não encavaladas conforme foi demonstrado no resultado anterior.

 
 

O mesmo resultado seria apresentado escrevendo-se:

 
 

@Override

public void run() {

synchronized(lock1){ …. Ou synchronized(this)

demonstra1();

demonstra2();

}

}

Anúncios
Esta entrada foi publicada em Java, Threads com as etiquetas . ligação permanente.

Deixe uma Resposta

Preencha os seus detalhes abaixo ou clique num ícone para iniciar sessão:

Logótipo da WordPress.com

Está a comentar usando a sua conta WordPress.com Terminar Sessão /  Alterar )

Google+ photo

Está a comentar usando a sua conta Google+ Terminar Sessão /  Alterar )

Imagem do Twitter

Está a comentar usando a sua conta Twitter Terminar Sessão /  Alterar )

Facebook photo

Está a comentar usando a sua conta Facebook Terminar Sessão /  Alterar )

Connecting to %s