Concessões de thread: rendimento ()
O objetivo do rendimento () é desistir. Ele pode permitir que o encadeamento atual entre no "estado pronto" do "estado em execução", para que outros threads de espera com a mesma prioridade possam obter direitos de execução; No entanto, não pode garantir que, após o rendimento do encadeamento atual (), outros threads com a mesma prioridade definitivamente obterão direitos de execução; Também pode ser que o thread atual entra no "estado de corrida" e continue a ser executado!
Exemplo:
classe threada estende thread {public threada (nome da string) {super (nome); } public sincronizado void run () {for (int i = 0; i <10; i ++) {System.out.printf ("%s [%d]:%d/n", this.getName (), this.getPriority (), i); // Quando eu é dividido por 4, ligue para o rendimento se (i%4 == 0) Thread.yield (); }}} classe pública hieldtest {public static void main (string [] args) {threada t1 = new ThreadA ("t1"); Threada T2 = new Threada ("T2"); t1.start (); t2.start (); }} (Uma vez) Resultado da operação:
T1 [5]: 0t2 [5]: 0t1 [5]: 1t1 [5]: 2t1 [5]: 3t1 [5]: 4t1 [5]: 5t1 [5]: 6t1 [5]: 7t1 [5]: 8t1 [5]: 9t2 [5] [5]: 5t1 [5]: 8t1 [5]: 9T2 [5] [5: 1t2 [5]: [5]: 6T2 [5]: 7T2 [5]: 8T2 [5]: 9
Resultados Descrição:
Quando "Thread T1" pode ser inteiro por 4, ele não muda para "Thread T2". Isso mostra que, embora o rendimento () possa permitir que os threads entrem no "estado pronto" do "estado de corrida", não permite necessariamente que outros threads obtenham direitos de execução da CPU (ou seja, outros threads entram no "estado em execução"), mesmo que esse "outro thread" tenha a mesma prioridade que o encadeamento atualmente chamando rendimento ().
Comparação de rendimento () e wait ():
Sabemos que a função de wait () é permitir que o thread atual entre no "espera (bloqueando) do estado do" estado em execução "e também libere o bloqueio de sincronização. A função do rendimento () é desistir, o que também fará com que o encadeamento atual deixe o" estado de corrida ". Suas diferenças são:
(1) espera () é deixar o thread entrar no "estado de espera (bloqueando)" do "estado em execução", embora não seja rendido () é deixar o thread entrar no "estado pronto" do "estado em execução".
(2) Wait () é uma trava de sincronização que será lançada o objeto que ele mantém, enquanto o método de rendimento () não liberará o bloqueio.
O exemplo a seguir mostra que o rendimento () não liberará o bloqueio:
classe pública hieldlocktest {objeto estático privado obj = new Object (); public static void main (string [] args) {threada t1 = new Threada ("t1"); Threada T2 = new Threada ("T2"); t1.start (); t2.start (); } classe estática threada estende thread {public threada (nome da string) {super (nome); } public void run () {// Get Sincronized (obj) {for (int i = 0; i <10; i ++) {System.out.printf ("%s [%d]:%d/n", this.getName (), this.getPriority (), i); // Quando eu é dividido por 4, ligue para o rendimento se (i%4 == 0) Thread.yield (); }}}}}} (Uma vez) resultado:
T1 [5]: 0t1 [5]: 1T1 [5]: 2T1 [5]: 3T1 [5]: 4T1 [5]: 5T1 [5]: 6T1 [5]: 7T1 [5]: 8t1 [5]: 9T2 [5]: 0T2 [5]: [5]: 6T2 [5]: 7T2 [5]: 8T2 [5]: 9
Resultados Descrição:
Dois threads T1 e T2 são iniciados na linha principal principal. T1 e T2 se referirão à trava de sincronização do mesmo objeto em run (), isto é, sincronizado (OBJ). Durante a operação T1, embora ele chama Thread.yield (); T2 não obterá direitos de execução da CPU. Porque T1 não libera a "trava síncrona mantida por Obj"!
Tópico Sono: Sono ()
o sono () é definido em thread.java.
A função do Sleep () é deixar o fio atual dormir, ou seja, o encadeamento atual entrará do "estado em execução" para o "estado de sono (bloqueio)". O sono () especificará o tempo de sono e o tempo de sono do fio será maior que/igual ao tempo de sono; Quando o tópico for despertado novamente, ele mudará de um "estado de bloqueio" para um "estado pronto", aguardando a programação da CPU.
Exemplo:
classe threada estende thread {public threada (nome da string) {super (nome); } public sincronizado void run () {try {for (int i = 0; i <10; i ++) {System.out.printf (" %s: %d/n", thisgetName (), i); // Quando eu posso ser dividido por 4, durma por 100ms se (i%4 == 0) Thread.sleep (100); }} catch (interruptEdException e) {e.printStackTrace (); }}} public class SleepTest {public static void main (string [] args) {threada t1 = new Threada ("t1"); t1.start (); }} Resultados em execução:
T1: 0t1: 1t1: 2t1: 3t1: 4t1: 5t1: 6t1: 7t1: 8t1: 9
Resultados Descrição:
O programa é relativamente simples, inicie o encadeamento T1 no thread principal principal. Após o início do T1, quando o cálculo I em T1 pode ser divisível por 4, o T1 dormirá por 100 milissegundos através do thread.Sleep (100).
Comparação de Sleep () e Wait ():
Sabemos que a função de wait () é permitir que o thread atual entre no "aguarde (bloqueando) do" estado em execução "e também solte o bloqueio de sincronização. A função do Sleep () é deixar o encadeamento atual entrar no" Sleep (bloqueio) do estado "do" estado de corrida ".
No entanto, Wait () libera o bloqueio de sincronização do objeto, enquanto o Sleep () não libera o bloqueio.
O exemplo a seguir mostra que o Sleep () não liberará o bloqueio.
classe pública sleeplocktest {objeto estático privado obj = new Object (); public static void main (string [] args) {threada t1 = new Threada ("t1"); Threada T2 = new Threada ("T2"); t1.start (); t2.start (); } classe estática threada estende thread {public threada (nome da string) {super (nome); } public void run () {// Obtenha o bloqueio de sincronização do objeto obj sincronizado (obj) {try {for (int i = 0; i <10; i ++) {System.out.printf (" %s: %d/n", this.getname (), i); // Quando eu posso ser dividido por 4, durma por 100ms se (i%4 == 0) Thread.sleep (100); }} catch (interruptEdException e) {e.printStackTrace (); }}}}}}}}} Resultados em execução:
T1: 0T1: 1T1: 2T1: 3T1: 4T1: 5T1: 6T1: 7T1: 8T1: 9T2: 0T2: 1T2: 2T2: 3T2: 4T2: 5T2: 6T2: 7T2: 8T2: 9
Resultados Descrição:
Dois threads T1 e T2 são iniciados na linha principal principal. T1 e T2 se referirão à trava de sincronização do mesmo objeto em run (), isto é, sincronizado (OBJ). Durante o T1 em execução, embora ele chame thread.sleep (100); T2 não obterá direitos de execução da CPU. Porque T1 não libera a "trava síncrona mantida por Obj"!
Observe que, se comentarmos sincronizados (OBJ) e executarmos o programa novamente, o T1 e o T2 poderão ser alterados um para o outro. A seguir, o código -fonte após o comentário sincronizado (OBJ):
classe pública sleeplocktest {objeto estático privado obj = new Object (); public static void main (string [] args) {threada t1 = new Threada ("t1"); Threada T2 = new Threada ("T2"); t1.start (); t2.start (); } classe estática threada estende thread {public threada (nome da string) {super (nome); } public void run () {// Obtenha o bloqueio de sincronização do object obj // sincronizado (obj) {try {for (int i = 0; i <10; i ++) {System.out.printf (" %s: %d/n", this.getname (), i); // Quando eu posso ser dividido por 4, durma por 100ms se (i%4 == 0) Thread.sleep (100); }} catch (interruptEdException e) {e.printStackTrace (); } //}}}}