Quando vi essa pergunta pela primeira vez, não pude começar porque senti que sincronizado e o bloqueio eram muito diferentes em termos de bloqueio. Por exemplo, consulte como travar quando sincronizado em circunstâncias normais.
Método 1:
public sincronizado vazio a () {// TODO}Método 2:
public void b () {sincronizado (this) {// TODO}}Dessas duas maneiras, o bloqueio é adicionado entre {}. Vamos dar uma olhada em como o bloqueio é feito:
public void C () {Lock.lock (); tente {// TODO} finalmente {Lock.unlock (); }}Essa maneira de bloquear é adicionada entre Lock () e desbloqueio (). Portanto, se você deseja implementar uma função de bloqueio, precisa pensar em como implementar esses dois métodos, Métodos Lock () e desbloquear (), primeiro defina uma estrutura da seguinte maneira:
public void Lock () {} public void Unlock () {}Então você deve pensar em como usar sincronizado para implementar esses dois métodos.
Agora estou um pouco mais claro em minha mente, mas não sei como preencher esses dois métodos. Veja como analisar as características do bloqueio de Lock e depois dar uma olhada neste código:
public void C () {Lock.lock (); // Quando o fio atual é obtido o bloqueio, outro thread precisa esperar, tente {// Thread atual entre na trava, outro thread não pode entrar // TODO} finalmente {Lock.unlock (); // Liberação atual do Thread}}}Acabei de adicionar um pequeno comentário sobre este código e não fiz mais nada. Está ajudando a entender esse código e ver qual é a palavra mais frequente, currentThread? Então, quando preenchemos os métodos Lock () e desbloqueio (), devemos prestar atenção ao agarrar a palavra -chave CurrentThread para encontrar a solução? A resposta é sim.
Em seguida, analise, como fazer o thread esperar ao usar sincronizado? É usar o método wait (). Como acordar o tópico? Ele usa o método notify (). Em seguida, você precisa usar o método Wait () no método Lock () e o método notify () no método desbloqueio (). Então, quando usamos espera () e notify (), temos uma condição. Pense no que devemos usar como condição?
Devemos usar se o bloqueio atual é ocupado como uma condição de julgamento. Se o bloqueio estiver ocupado, o currentThread Wait. Pense se estamos usando essa condição ao usar sincronizado. A resposta é sim.
Vamos analisar quando liberar o bloqueio e quais condições são usadas. Pense se o thread A recebe a fechadura, o Thread B pode ser lançado? Claro que não. Se B puder ser lançado, viola o princípio, é claro que não. Definitivamente, a fechadura do Thread A só pode ser lançada. Portanto, a condição de julgamento é julgar se o thread que mantém a fechadura é o CurrentThread. Nesse caso, pode ser lançado, mas é claro que não pode.
Vamos dar uma olhada no código completo agora:
pacote test.lock; importar java.util.random; importar java.util.Concurrent.ExecutorService; importar java.util.concurrent.executores; importar java.util.Concurrent.ThreadFactory; public class; Sincronizado Void Lock () {Long currentThreadId = Thread.CurrentThread (). GetId (); if (proprietário == currentThreadId) {lança new IllegalStateException ("Lock foi adquirido por ThreadIdid");} while (thread.islooked ()) {System.out.println (string.Format ("THINE (thread (thread.islooked ()) {System.out.Println (string.Format (" thread (threads); {wait ();} catch (interruptEdException e) {e.printStackTrace ();}} proprietário = currentThreadId; system.out.println (string.format ("bloqueio é adquirido por thread %s", proprietário);} public synchronized void desblock () {if (! IlegalStateException ("Somente o proprietário do bloqueio pode desbloquear o bloqueio");} system.out.println (string.format ("Thread %s está desbloqueando", proprietário)); system.out.println (); proprietário = nenhum; notify (); Executores.NewfixedThreadpool (20, new ThreadFactory () {private ThreadGroup Group = new ThreadGroup ("Grupo de threads de teste"); {group.setDaemon (true);}@substituir public thread threads newthread (runnable r) {return thread (grupo r);}}); para (int i = 0; {@Override public void run () {Lock.lock (); System.out.println (String.Format ("Thread %s está em execução ...", Thread.CurrentThread (). {E.PrintStackTrace ();} Lock.unlock ();}});}}}Execute -o e veja os resultados:
O bloqueio é adquirido por rosca 8, rosca 8 está em funcionamento ... A linha 27 está esperando o fio da trava 26 está esperando o fio da trava 25 está esperando o fio da trava 24 está esperando o fio da trava 23 está esperando o fio da trava 22 está esperando o fio da trava 21, a rosca de fechadura do bloqueio do bloqueio está esperando rosca de bloqueio, o fio do bloqueio do bloqueio, o fio do bloqueio, o fio do bloqueio do bloqueio, o fio do bloqueio do bloqueio, o fio do bloqueio do bloqueio, o fio do bloqueio do bloqueio, o fio do bloqueio do bloqueio. 27 thread 27 is running... thread 27 is unlocking Lock is acquired by thread 26 thread 26 is running... thread 26 is unlocking Lock is acquired by thread 25 thread 25 is running... thread 25 is unlocking Lock is acquired by thread 24 thread 24 is running... thread 24 is unlocking Lock is acquired by thread 23 thread 23 is running... thread 23 is unlocking Lock is acquired by thread 22 thread 22 is running... thread 22 is unlocking Lock is acquired by thread 21 thread 21 is running... thread 21 is unlocking Lock is acquired by thread 20 thread 20 is running... thread 20 is unlocking Lock is acquired by thread 19 thread 19 is running... thread 19 is unlocking Lock is acquired by thread 18 thread 18 is running... thread 18 is unlocking Lock is acquired by thread 17 thread 17 is running... thread 17 is unlocking Lock is acquired by thread 16 thread 16 is running... thread 16 is unlocking Lock is acquired by thread 15 thread 15 is running... thread 15 is unlocking Lock is acquired by thread 14 thread 14 is running... thread 14 is unlocking Lock is acquired Por thread 13 Thread 13 está em execução ... o thread 13 está desbloqueando a bloqueio é adquirida pelo thread 12 Thread 12 está em execução ... o encadeamento 12 está desbloqueando o bloqueio é adquirido pelo thread 11 Thread 11 está em execução ... o encadeamento 11 está desbloqueando o bloqueio é adquirido pelo thread 10 10 está em execução ... o thread 10 está desbloqueando o bloqueio é adquirido pelo thread 9 está em execução ... o Thread 9 está desbloqueando
Se você alterar o loop for 30 vezes, observe os resultados:
O bloqueio é adquirido por rosca 8, rosca 8 está em funcionamento ... A linha 27 está esperando o fio da trava 26 está esperando o fio da trava 25 está esperando o fio da trava 24 está esperando o fio da trava 23 está esperando o fio da trava 22 está esperando o fio da trava 21, a rosca de fechadura do bloqueio do bloqueio está esperando rosca de bloqueio, o fio do bloqueio do bloqueio, o fio do bloqueio, o fio do bloqueio do bloqueio, o fio do bloqueio do bloqueio, o fio do bloqueio do bloqueio, o fio do bloqueio do bloqueio, o fio do bloqueio do bloqueio. 27 A linha 27 está em execução ... A linha 8 está esperando a linha de bloqueio 27 está desbloqueando o bloqueio é adquirido pelo fio 27 A linha 27 está em execução ... A linha 26 está aguardando o fio de bloqueio 27 está desbloqueando o bloqueio é adquirido por rosca 27 está em execução ... Thread 25 está esperando a linha de rosca 27 é desbloqueado, a bloqueio é adquirida 23 23 23 Is 24 Is Running está em execução ... Running ... 27 Is 27 está esperando a linha 24, a trava é adquirida por 23 23 23 23 23 Is 24 Is Running Is Running Running ... 27 Is 27 Is Lock 24 is waiting lock thread 22 is unlocking Lock is acquired by thread 22 thread 22 is running... thread 21 is waiting lock thread 22 is unlocking Lock is acquired by thread 22 thread 22 is running... thread 20 is waiting lock thread 22 is unlocking Lock is acquired by thread 22 thread 22 is running... thread 19 is waiting lock thread 22 is unlocking Lock is acquired by thread 22 thread 22 is running... thread 18 is waiting lock thread 22 is unlocking Lock is acquired by thread 17 thread 17 is running... thread 17 is unlocking Lock is acquired by A rosca 16 está em execução ... A rosca 16 está desbloqueando a bloqueio é adquirida pelo encadeamento 15, está em execução ... A rosca 15 está desbloqueando o bloqueio é adquirido pelo encadeamento 14 Freia 14 está em execução ... A rosca 14 está desbloqueando o bloqueio é adquirido por rosca 13, a rosca 13 está em execução. by thread 9 thread 9 is running... thread 9 is unlocking Lock is acquired by thread 8 thread 8 is running... thread 8 is unlocking Lock is acquired by thread 26 thread 26 is running... thread 26 is unlocking Lock is acquired by thread 25 thread 25 is running... thread 25 is unlocking Lock is acquired by thread 27 thread 27 is running... thread 27 is unlocking Lock is acquired by thread 24 thread 24 is running... thread 24 is unlocking Lock is acquired by thread 23 thread 23 is running... thread 23 is unlocking Lock is adquirido pelo thread 21 Thread 21 está em execução ... o thread 21 está desbloqueando o bloqueio é adquirido pelo thread 20 Thread 20 está em execução ... o thread 20 está desbloqueando o bloqueio é adquirido pelo thread 19 Thread 19 está em execução ... o thread 19 está desbloqueando o bloqueio é adquirido pelo thread 18
Resumir
O exposto acima é toda a explicação detalhada deste artigo sobre o uso de sincronizado para implementar um código de bloqueio. Espero que seja útil para todos. Amigos interessados podem continuar se referindo a este site:
Exemplo de código de bloqueio de sincronização de síncronização de threads java thread
A diferença entre sincronizado e bloqueio na programação Java [recomendado]
Java Multithreaded ReadWritelock Read-Write Separation Implementation Code
Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!