Impasse
O parafuso é uma ferramenta muito útil com muitos aplicativos, porque é muito simples de usar e fácil de entender. Mas, ao mesmo tempo, também trará alguns problemas, ou seja, pode causar impasse. Uma vez que um impasse, as funções do sistema não estarão disponíveis. Vamos primeiro olhar para um pedaço de código, que causará impulsos, fazendo com que o Thread Thread_1 e o Thread Thread_2 aguardem que ele libere o bloqueio.
Pacote thread; public class deadlockdemo {string estática privada a = "a"; string estática privada b = "b"; public static void main (string args []) {new Deadlockdemo (). Deadlock ();} (runnlable privado () {// Thread_1). {System.err.println ("-Thread_1 bloqueie a ----"); sincronizado (b) {System.err.println ("-Thread_1 Lock B ----");}}}}}); // Thread_2 Thread_h Thread_2 = new Runnable () {@Override Void Von {System.out.println ("-Thread_2 Lock B -----"); sincronizado (a) {System.out.println ("-Thread_2 bloqueia a ----");}}}}); thread_1.start (); thread_2.start ();}}}}}}}});Esse código é apenas uma demonstração de cenários de impasse e, na realidade, você não pode escrever esse código. Mas em alguns cenários mais complexos, você pode encontrar esses problemas, como Thread_1 não lançou o cabo porque algumas situações anormais (Loop Dead). Ou Thread_1 obtém um cabo de banco de dados e uma exceção é lançada ao liberar o bloqueio, mas não é liberado.
Uma vez que um impasse, o negócio é perceptível porque o serviço não pode ser fornecido. Em seguida, você pode verificar apenas qual thread tem o problema através do tópico do despejo. As informações do tópico a seguir nos dizem que as linhas 35 e 21 da aula de DeadlockDemo causaram o impasse.
"Thread -1" prio = 6 Tid = 0x000000000cb13800 nid = 0x19ac aguardando a entrada do monitor [0 x000000000d67f000] java.lang.Thread.State: Blocked (no objeto) em thread.deadlockdemo $ 2.run (deadlockDemo.java:35) java.lang.string) - bloqueado <0x00000007d5a9beb8> (a java.lang.string) em java.lang.thread.run (fonte desconhecida) "thread -0" prio = 6 tid = 0x00000000000000000000 NID = 0x6bc = 6 Tid = 0x00000000000000000000 ids = 0x6bc = 6 tid = 0x00000000000000000000 ids = 0x6bc = 6 Tid = 0x00000000000000000000 NID = 0x6bc = 6 tid = 0x00000000000000000000 ids = 0x6bc = 6 Tid = 0x00000000000000000000 NID = 0x6bc = 6 TID para entrada = 0x0000000000000000000000 ids = 0x6bc = 6 Tid = 0x0000000000001 java.lang.Thread.State: BLOCKED (on object monitor) at thread.DeadLockDemo$1.run(DeadLockDemo.java:21) - waiting to lock <0x00000007d5a9beb8> (a java.lang.String) - locked <0x00000007d5a9be88> (a java.lang.String) at java.lang.thread.run (fonte desconhecida)
Várias maneiras comuns de evitar impasse.
Evite adquirir vários bloqueios ao mesmo tempo que um thread.
Evite um tópico que ocupe vários recursos ao mesmo tempo na corda e tente garantir que cada corda consome apenas um recurso.
Tente usar a pesquisa cronometrada, usando Lock.TryLock (Timeout) em vez de usar o mecanismo de pesquisa interna.
Para cabos de banco de dados, bloqueio e desbloqueio devem estar em uma conexão de banco de dados, caso contrário, o desbloqueio falhará.
referência:
//www.vevb.com/article/131946.htm
//www.vevb.com/article/131943.htm
Resumir
O exposto acima é a análise completa do código dos métodos comuns de Java para evitar impasse neste artigo. Espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!