Diferença entre wait () e sleep ()

Question

Qual é a diferença entre um wait() e sleep() em Threads?

É meu entendimento que a Thread-ing wait() ainda está em executar ciclos de CPU de modo e usos, mas um sleep()-ing não consome quaisquer ciclos de CPU correto?

Por que temos ambos wait() e sleep():? Como é que a sua implementação variam em um nível inferior

Answer 1

A wait pode ser "acordado" por outro segmento chamando notify no monitor que está sendo aguardado enquanto que um sleep não pode. Também um wait (e notify) deve acontecer em um synchronized bloco no objeto do monitor enquanto sleep não:

Object mon = ...;
synchronized (mon) {
    mon.wait();
} 

Neste ponto, os atualmente em execução thread espera e libera o monitor . Outro segmento pode fazer

synchronized (mon) { mon.notify(); }

(no mesmo objeto mon) e o primeiro segmento (supondo que ele é o único fio à espera do monitor) vai acordar.

Você também pode ligar para notifyAll se mais de um segmento está aguardando no monitor - este vai acordar todas elas up . No entanto, apenas um dos tópicos será capaz de agarrar o monitor (lembre-se que o wait está em um bloco synchronized) e continue -. Os outros serão bloqueados até que eles podem adquirir bloqueio do monitor

Outro ponto é que você chama wait em Object si (ou seja, você espera no monitor de um objeto), enquanto você chama sleep em Thread .

No entanto, outro ponto é que você pode obter wakeups espúrias de wait (ou seja, a discussão que está esperando currículos sem razão aparente). Você deve sempre wait enquanto girando em alguma condição como segue:

synchronized {
    while (!condition) { mon.wait(); }
}

Answer 2

Uma diferença fundamental ainda não mencionado é que durante o sono a Thread não liberar os bloqueios que detém, enquanto espera libera o bloqueio sobre o objeto que wait() é chamado.

synchronized(LOCK) {
    Thread.sleep(1000); // LOCK is held
}


synchronized(LOCK) {
    LOCK.wait(); // LOCK is not held
}

Answer 3

este post útil. Ela coloca a diferença entre Thread.sleep(), Thread.yield() e Object.wait() em termos humanos. Para citar:

Tudo, eventualmente, faz o seu caminho para baixo para programador do sistema operacional, que mãos fora timeslices para processos e threads.

sleep(n) diz “Eu sou feito com meu timeslice, e por favor, não me dê outro para pelo menos n milissegundos.” A OS nem sequer tentar agendar o fio de dormir até a hora solicitada passou.

yield() diz “Eu sou feito com meu timeslice, mas eu ainda tenho trabalho a fazer “. O sistema operacional é livre para dar imediatamente o fio outra fatia de tempo, ou dar algum outro processo ou segmento da CPU o segmento produzindo simplesmente desistiu.

wait() diz “Eu sou feito com meu timeslice. Não me dar outra timeslice até que alguém chamadas notificar ().” Como com sleep(), o OS não vai mesmo tentar agendar sua tarefa a menos que alguém chama notify() (ou um dos alguns outros cenários de despertar ocorre).

Threads também perdem o restante de sua fatia de tempo quando eles executam IO bloqueio e sob algumas outras circunstâncias. Se funciona uma rosca através de toda a fatia de tempo, o sistema operacional à força toma o controle mais ou menos como se yield() tinha sido chamado, para que outros processos podem ser executados.

Você raramente precisa yield(), mas se você tiver um aplicativo de computação pesada com limites de tarefas lógicas, inserindo um yield() pode Sistema de melhorar capacidade de resposta (à custa de tempo - mudanças de contexto, mesmo que apenas para o sistema operacional e para trás, não são livres). Medida e teste contra objetivos que você preocupam, como sempre.

Answer 4

Existem muitas respostas aqui, mas eu não conseguia encontrar a distinção semântica mencionado em qualquer.

Não é sobre o próprio fio; ambos são necessários métodos como eles suportam muito diferentes casos de uso.

sleep() envia a linha para o sono como era antes, ele só embala o contexto e pára a execução por um tempo pré-definido. Assim, a fim de despertá-lo antes do tempo devido, você precisa saber a referência Thread. Esta não é uma situação comum em um ambiente multi-threaded. É usado principalmente para de sincronização de tempo (por exemplo acordar em exatamente 3,5 segundos) e / ou justiça hard-coded (sono apenas por um tempo e deixar que os outros threads de trabalho).

wait(), pelo contrário, é um mecanismo de sincronização thread (ou mensagem) que lhe permite notificar um fio de que você não tenha armazenado de referência (ou cuidado). Você pode pensar nisso como um padrão de publicação-assinatura (wait == subscrever e notify() == publicar). Basicamente utilizando notificar () que você está enviando uma mensagem (que pode até não ser recebido em tudo e normalmente você não se importa).

Para resumir, você normalmente usa sleep() para o tempo-syncronization e wait() para multi-thread-sincronização.

Eles podem ser implementados da mesma maneira no sistema operacional subjacente, ou não em todos (como as versões anteriores do Java não tinha multithreading real; provavelmente algumas pequenas VMs não fazer isso também). Não se esqueça corridas Java em uma máquina virtual, de modo que seu código será transformado em algo diferente de acordo com o VM / OS / HW onde pode correr.

Answer 5

Aqui, eu listei algumas diferenças importantes entre os métodos wait() e sleep().
PS:. Também clique nos links para ver o código da biblioteca (trabalho interno, apenas brincar um pouco para melhor compreensão)

wait ()

1. método wait() libera o bloqueio.
2. wait() é o método de classe Object.
3. wait() é o método não-estático - public final void wait() throws InterruptedException { //...}
4. wait() deve ser notificado por métodos notify() ou notifyAll().

5. necessidades método wait() a ser chamado a partir de um circuito para lidar com falso alarme.

6. método wait() deve ser chamado a partir do contexto sincronizado (método ou bloco isto é sincronizado), caso contrário irá jogar IllegalMonitorStateException

sleep ()

1. método sleep() não libera o bloqueio.
2. sleep() é o método de classe java.lang.Thread.
3. sleep() é o método estático - public static void sleep(long millis, int nanos) throws InterruptedException { //... }
4. após o período de tempo especificado, sleep() está concluída.
5. sleep() melhor não chamada de loop (i. ver código abaixo ).
6. sleep() pode ser chamado de qualquer lugar. não há nenhuma exigência específica.

Ref: Diferença entre Wait and Sleep

Código trecho para chamar espera e método de suspensão

synchronized(monitor){
    while(condition == true){ 
        monitor.wait()  //releases monitor lock
    }

    Thread.sleep(100); //puts current thread on Sleep    
}

Answer 6

Existem algumas notas fundamentais diferença Concluo depois de trabalhar em espera e sono, primeiro dar uma olhada na amostra usando wait () e sleep ():

Example1 : usando espera () e suspensão ():

synchronized(HandObject) {
    while(isHandFree() == false) {
        /* Hand is still busy on happy coding or something else, please wait */
        HandObject.wait();
    }
}

/* Get lock ^^, It is my turn, take a cup beer now */
while (beerIsAvailable() == false) {
    /* Beer is still coming, not available, Hand still hold glass to get beer,
       don't release hand to perform other task */
    Thread.sleep(5000);
}

/* Enjoy my beer now ^^ */
drinkBeers();

/* I have drink enough, now hand can continue with other task: continue coding */
setHandFreeState(true);
synchronized(HandObject) {
    HandObject.notifyAll();
}

Let clareza algumas notas fundamentais:

1. Chamada em :
   • wait (): chamada em thread atual que espera HandObject objeto
   • sleep (): Chamada de Tópico executar cerveja tarefa get (é método de classe para efeito sobre segmento em execução atual)
2. Synchronized :
   • wait (): quando sincronizada de multi acesso rosca mesmo objeto (HandObject) (Quando a comunicação necessidade entre mais de um thread (thread executar codificação, linha executar obter cerveja) de acesso na mesma HandObject objeto)
   • sleep (): quando esperando condição para continuar a executar (Esperando cerveja disponíveis)
3. Bloqueio de Retenção :
   • wait (): libertar o bloqueio para outro objeto tem chance de executar (HandObject é livre, você pode fazer outro trabalho)
   • sleep (): bloqueio manterá por pelo menos t vezes (ou até interrupção) (Meu trabalho ainda não terminou, eu sou continuar bloqueio espera e esperando alguma condição para continuar)
4. condição de despertar :
   • wait (): até chamada notificar (), notifyAll () do objeto
   • sleep (): pelo menos até o tempo expirar ou chamada de interrupção
5. E o último ponto é uso quando como Estani indicam:

que você usa normalmente sleep () para o tempo-syncronization e wait () para multi-thread-sincronização.

Por favor me corrija se eu estiver errado.

Answer 7

Diferença entre wait () e sleep ()

• A diferença fundamental é que wait() é de Object e sleep() é um método estático de Thread.

• A grande diferença é que wait() libera a trava enquanto sleep() não libera qualquer bloqueio enquanto espera.

• wait() é usado para comunicação inter-thread enquanto sleep() é usada para introduzir uma pausa na execução, em geral.

• wait() deve ser chamado de sincronizar dentro ou então temos uma IllegalMonitorStateException, enquanto sleep() pode ser chamado em qualquer lugar.

• Para iniciar uma discussão novamente a partir wait(), você tem que notify() chamada ou notifyAll(). Quanto sleep(), o fio é iniciada após um intervalo de tempo especificado.

Semelhanças

• Ambos fazem movimento thread atual para o Não Runnable Estado.
• Ambos são nativas métodos.

Answer 8

Esta é uma pergunta muito simples, porque ambos os métodos têm um uso totalmente diferente.

A principal diferença é que esperar para liberar o bloqueio ou monitor enquanto o sono não libera qualquer bloqueio ou monitor enquanto espera. Espera é usado para comunicação inter-thread enquanto o sono é usada para introduzir uma pausa na execução.

Este foi apenas uma explicação clara e básica, se você quer mais do que isso, em seguida, continuar a leitura.

Em caso de rosca método wait() vai em estado de espera e não vai voltar automaticamente até que nós chamamos o método notify() (ou notifyAll() se você tiver mais de um segmento em estado de espera e você quer acordar todos aqueles fios) . E você precisa sincronizado ou o bloqueio objeto ou bloqueio classe para acessar o wait() ou métodos notify() ou notifyAll(). E mais uma coisa, o método wait() é usado para comunicação inter-thread porque se um fio vai em estado de espera você vai precisar de outro segmento para acordar esse segmento.

Mas no caso de sleep() este é um método que é usado para manter o processo por alguns segundos ou o tempo que você queria. Porque você não precisa de provocar qualquer método notify() ou notifyAll() para obter isso de volta fio. Ou você não precisa de qualquer outro segmento para chamar de volta esse segmento. Como se você quer algo deve acontecer após alguns segundos, como em um jogo após o turno de usuário que você deseja que o usuário aguarde até que o computador joga, então você pode mencionar o método sleep().

E uma diferença mais importante do que é pedido, muitas vezes em entrevistas:. sleep() pertence à classe Thread e wait() pertence à classe Object

Estas são todas as diferenças entre sleep() e wait().

E há uma semelhança entre os dois métodos:. Ambos são verificados declaração Então, você precisa tentar captura ou lança para acessar esses métodos

Espero que isso irá ajudá-lo.

Answer 9

Fonte: http://www.jguru.com/faq/view. jsp? EID = 47127

Thread.sleep() envia o segmento atual no "Não Runnable" estado por algum período de tempo. O fio mantém os monitores que tenha adquirido - isto é se o segmento é actualmente num bloco ou método de nenhum outro segmento sincronizado pode entrar neste bloco ou método. Se outro thread chama t.interrupt() ele vai acordar o fio dormir.

Note que o sono é um método estático, o que significa que sempre afeta o fio corrente (aquele que está a executar o método de sono). UMA erro comum é t.sleep() chamada onde t é um segmento diferente; mesmo assim, é o atual segmento que o sono vontade, não o fio t.

t.suspend() é obsoleto. Usá-lo é possível parar um segmento diferente que o segmento atual. Um segmento suspenso mantém todas as suas monitores e uma vez que este estado não é interrompível é impasse propenso.

object.wait() envia o segmento atual no "Não Runnable" estado, como sleep(), mas com uma torção. Wait for chamado em um objeto, não um fio; nós chamamos este objeto o "objeto de bloqueio." Antes lock.wait() é chamado, o atual segmento deve sincronizar sobre o objeto de bloqueio; wait() em seguida, libera esse bloqueio, e acrescenta a linha para a "lista de espera" associado com a fechadura. Mais tarde, outro segmento pode sincronizar na mesmo objeto de bloqueio e lock.notify() chamada. Este acorda o original, esperando fio. Basicamente, wait() / notify() é como sleep() / interrupt(), somente o segmento ativo não precisa de um direto ponteiro para o segmento de dormir, mas apenas para o objeto de bloqueio compartilhado.

Answer 10

Wait e dormir são duas coisas diferentes:

• Em sleep() o fio pára de funcionar durante o período especificado.
• Em wait() o fio pára de funcionar até que o objeto ser esperou-on é notificado, geralmente por outros threads.

Answer 11

sleep é um método de Thread, wait é um método de Object, então wait/notify é uma técnica de sincronização de dados compartilhados em Java (usando monitor de ), mas sleep é um método simples de rosca para fazer uma pausa em si.

Answer 12

sleep () é um método que é usado para manter o processo por alguns segundos ou o tempo que você queria, mas em caso de wait () rosca método vai em estado de espera e que não virá volta automaticamente até que chamamos de notificar () ou notifyAll ().

O grande diferença é que wait () libera o bloqueio ou monitor enquanto o sono () não libera qualquer bloqueio ou monitor enquanto espera. Espera é usado para comunicação inter-thread enquanto o sono é usada para introduzir uma pausa na execução, em geral.

Thread.sleep () envia o segmento atual para o estado “Not Runnable” por algum período de tempo. O fio mantém os monitores que adquiriu - ou seja, se o segmento está atualmente em um bloco ou método nenhum outro segmento sincronizado pode entrar neste bloco ou método. Se outro thread chama t.interrupt () que vai acordar o fio dormir. Note-se que o sono é um método estático, o que significa que sempre afeta o segmento atual (aquele que está executando o método de sono). Um erro comum é t.sleep call (), onde t é um segmento diferente; mesmo assim, é o atual segmento que o sono vontade, não o fio t.

object.wait () envia o segmento atual para o estado “Not Runnable”, como o sono (), mas com uma torção. Wait for chamado em um objeto, não um fio; nós chamamos este objeto o “objeto de bloqueio.” Antes lock.wait () é chamado, o atual segmento deve sincronizar sobre o objeto de bloqueio; wait (), em seguida, libera esse bloqueio, e acrescenta a linha para a “lista de espera” associado com o bloqueio. Mais tarde, outro segmento pode sincronizar no mesmo objeto de bloqueio e chamar lock.notify (). Este acorda do original, linha de espera. Basicamente, wait () / notify () é como o sono () / interrupção (), somente o segmento ativo não precisa de um ponteiro direto para o segmento de dormir, mas apenas para o objeto de bloqueio compartilhado.

synchronized(LOCK) {   
   Thread.sleep(1000); // LOCK is held
}

synchronized(LOCK) {   
   LOCK.wait(); // LOCK is not held
}

Vamos classificar todos os pontos acima:

Call on:

• wait (): Chamada em um objeto; thread atual deve sincronizar sobre o objeto de bloqueio.
• sleep (): Chamada em um segmento; sempre atualmente em execução fio.

Synchronized:

• wait ():. quando sincronizados vários segmentos acessar mesmo objeto por um
• sleep ():. quando sincronizados vários segmentos esperar o sono por de dormir fio

Hold lock:

• wait ():. liberar o bloqueio de outros objetos para ter chance de executar
• sleep ():. bloqueio manterá por pelo menos vezes t se limite especificado ou alguém interrupção

Wake-up condition:

• wait (): até chamada notificar (), notifyAll () do objeto
• sleep ():. , pelo menos até o tempo expirar ou chamar interrupção ()

Usage:

• sleep (): de sincronização de tempo e;
• wait ():. para multi-thread-sincronização

Ref: diff sleep e wait

Answer 13

métodos

wait e sleep são muito diferentes:

• sleep não tem forma de "acordar-up",
• wait tem uma forma de "acordar-up" durante o período de espera, por outro segmento chamando notify ou notifyAll .

Agora que penso nisso, os nomes são confusos a esse respeito; no entanto sleep é um nome padrão e wait é como o WaitForSingleObject ou WaitForMultipleObjects no Win API.

Answer 14

Em palavras simples, espera é esperar até que alguns outros invoca rosca você enquanto o sono é "Não executar próxima declaração" por algum período de tempo especificado.

Além disso sono é método estático na classe Thread e opera no segmento, enquanto espera () está na classe Object e chamado em um objeto.

Outro ponto, quando você chamar espera em algum objeto, o segmento de sincronização envolver o objeto e, em seguida, espera. :)

Answer 15

A partir deste post: http://javaconceptoftheday.com / diferença, entre-wait-and-sono-methods-em-java /

wait () Método.

1) A discussão que chama método wait () libera a trava que detém.

2) O segmento recupera o bloqueio após outros segmentos chamam quer notificar () ou métodos no mesmo bloqueio notifyAll ().

3) wait () método deve ser chamado dentro do bloco sincronizado.

método 4) wait () é sempre chamado em objetos.

5) segmentos de espera pode ser acordado por outras threads chamando notificar métodos () ou notifyAll ().

6) para chamar o método wait (), segmento deve ter bloqueio objeto.

sleep () Método

1) A discussão que chama o método sleep () não liberar o bloqueio que detém.

2) sono () método pode ser chamado dentro ou fora do bloco sincronizado.

método 3) sleep () é sempre chamado em threads.

4) Fios de sono não pode ser acordado por outras threads. Se fizer assim, linha vai jogar InterruptedException.

5) Para chamar sleep () método, necessidade segmento não ter bloqueio objeto.

Answer 16

1. wait() é um método de classe Object.
   sleep() é um método de classe Thread.

2. sleep() permite que a linha para ir para o estado sleep para x milissegundos.
   Quando um segmento entra em it doesn’t release the lock estado de sono.

3. wait() permite thread para liberar o bloqueio e goes to suspended state.
   Esta discussão será activa quando um método notify() ou notifAll() é chamada para o mesmo objeto.

Answer 17

Um potencial grande diferença entre o sono / interrupção e espera / notificar é que

• interrupt() sleep() sempre lança uma exceção (por exemplo InterruptedException ) , enquanto
• notify() wait() não funciona.

Gerar uma exceção quando não for necessário é ineficiente. Se você tem tópicos comunicando uns com os outros a uma taxa elevada, então seria gerar uma grande quantidade de exceções se você estivesse chamando de interrupção o tempo todo, o que é um desperdício total de CPU.

Answer 18

Você está correto - Sleep () faz com que esse segmento para "dormir" ea CPU vai sair e processar outros tópicos (também conhecido como troca de contexto) wheras Acredito Wait mantém a CPU processa a linha de corrente

.

Temos tanto porque embora possa parecer sensato deixar que outras pessoas usam a CPU enquanto você não estiver usando, actualy há uma sobrecarga de troca de contexto - dependendo de quanto tempo o sono é para, ele pode ser mais caro em ciclos de CPU para tópicos de switch que é para simplesmente ter o seu fio sem fazer nada por alguns ms.

Além disso, note que as forças de sono uma mudança de contexto.

Também - em geral, não é possível a troca de contexto controle -. Durante a espera o OS pode (e vai para esperas mais longas) optar por processar outros tópicos

Answer 19

Os métodos são usados ??para coisas diferentes.

Thread.sleep(5000);   // Wait until the time has passed.

Object.wait();        // Wait until some other thread tells me to wake up.

Thread.sleep (n) pode ser interrompido, mas Object.wait () deve ser notificado. É possível especificar o tempo máximo de espera:. Object.wait(5000) por isso seria possível usar wait para, er, sleep mas então você tem que se preocupar com bloqueios

Nenhum dos métodos usa a CPU durante o sono / espera.

Os métodos são implementados usando código nativo, usando construções semelhantes, mas não da mesma forma.

Olhe para si mesmo: é o código fonte de métodos nativos disponíveis? o /src/share/vm/prims/jvm.cpp arquivo é o ponto de partida ...

Answer 20

Aqui wait () será no estado de espera até que notificar por outro segmento, mas onde, como sleep () vai ter alguns time..after que serão transferidas automaticamente para o estado Pronto ...

Answer 21

Wait () e sleep () Diferenças?

Thread.sleep () Uma vez que o seu trabalho concluído, em seguida, apenas a sua liberação do bloqueio para todos. até que seu nunca liberar o bloqueio a ninguém.

  Sleep() take the key, its never release the key to anyone, when its work completed then only its release then only take the key waiting stage threads.

Object.wait () Quando a sua vai para a fase de espera, o seu será solte a tecla e sua espera para alguns dos segundos com base no parâmetro.

Por exemplo:

você é tomar o café na sua mão direita, você pode tomar um outro alguém do mesmo lado, quando vai a sua colocar para baixo só então tomar outro mesmo tipo de objeto aqui. Além disso. esta é sono () você dorme tempo que você não fez qualquer trabalho, você está fazendo única dormir .. mesmo aqui também.

wait (). quando você é colocado para baixo e tomar um outro meio quando você está esperando, que esperar

estiver filme jogo ou qualquer coisa no sistema de seu mesmo jogador não pode jogar mais do que um de cada certo tempo, isso é a sua aqui, quando você fechar e escolher outro filme qualquer um ou qualquer canção enquanto média é chamado de espera

Answer 22

wait libera o bloqueio e sleep não. Um segmento em estado de espera é elegível para acordar logo notify ou notifyAll é chamado. Mas no caso de sleep o segmento mantém o bloqueio e isso só vai ser elegível uma vez que o tempo de sono é longo.

Answer 23

método sleep() faz com que o segmento atual movimento de correr estado para estado do bloco por um tempo especificado. Se o segmento atual tem o bloqueio de qualquer objeto, em seguida, ele continua segurando-o, o que significa que outros segmentos não pode executar qualquer método sincronizado nesse objeto de classe.

método wait() faz com que o segmento atual entrar em estado de bloco, quer por um tempo especificado ou até que notificar, mas neste caso os lançamentos de rosca o bloqueio do objeto (o que significa que outros segmentos podem executar quaisquer métodos sincronizados do objeto chamando .

Answer 24

Na minha opinião, a principal diferença entre os dois mecanismos é que o sono / interrupção é a forma mais básica de fios de manuseio, enquanto espera / notificar é uma abstração destinada a fazer rosca inter-comunicação mais fácil. Isto significa que o sono / interrupção pode fazer qualquer coisa, mas que essa tarefa específica é mais difícil de fazer.

Por que esperar / notificar mais adequado? Aqui estão algumas considerações pessoais:

1. Ele reforça a centralização. Permite coordenar a comunicação entre um grupo de tópicos com um único objeto compartilhado. Isto simplifica o trabalho muito.

2. Obriga sincronização. Porque faz o programador embrulhar a chamada para esperar / notificar em um bloco sincronizado.

3. É independente da origem da linha e número. Com essa abordagem, você pode adicionar mais tópicos arbitrariamente sem editar outros tópicos ou manter uma faixa dos já existentes. Se você usou o sono / interrupção, primeiro você precisa para manter as referências aos tópicos de dormir, e depois interrompê-los um por um, à mão.

Um exemplo da vida real que é bom para explicar este é um restaurante clássico e o método que o pessoal usa para se comunicar entre eles: Os garçons deixam as solicitações dos clientes em um lugar central (uma placa de cortiça, uma mesa, etc .), toca uma campainha, e os trabalhadores da cozinha vir a tomar tais pedidos. Uma vez que não existe qualquer curso de pronto, o pessoal da cozinha tocar o sino novamente para que os garçons estão cientes e levá-los aos clientes.

Answer 25

Exemplo sobre o sono não libera bloqueio e espera faz

Aqui existem duas classes:

1. Principal :. Contém método principal e dois threads

2. Singleton :. Este é única classe com dois métodos estáticos getInstance () e getInstance (boolean isWait)

   public class Main {
   
   private static Singleton singletonA = null;
   private static Singleton singletonB = null;
   
   public static void main(String[] args) throws InterruptedException {
   
   Thread threadA = new Thread() {
       @Override
       public void run() {
   
           singletonA = Singleton.getInstance(true);
   
       }
   };
   
   Thread threadB = new Thread() {
       @Override
       public void run() {
           singletonB = Singleton.getInstance();
   
           while (singletonA == null) {
               System.out.println("SingletonA still null");
           }
   
           if (singletonA == singletonB) {
               System.out.println("Both singleton are same");
           } else {
               System.out.println("Both singleton are not same");
           }
   
       }
   };
   
   threadA.start();
   threadB.start();
   
    }
   }
   

e

public class Singleton {

    private static Singleton _instance;

    public static Singleton getInstance() {

    if (_instance == null) {
        synchronized (Singleton.class) {
            if (_instance == null)
                _instance = new Singleton();
        }
    }
    return _instance;

}

public static Singleton getInstance(boolean isWait) {

    if (_instance == null) {
        synchronized (Singleton.class) {
            if (_instance == null) {
                if (isWait) {
                    try {
                        // Singleton.class.wait(500);//Using wait
                        Thread.sleep(500);// Using Sleep
                        System.out.println("_instance :"
                                + String.valueOf(_instance));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                _instance = new Singleton();
            }
        }
    }
    return _instance;

 }
}

Agora executar este exemplo, você vai ficar abaixo da saída:

_instance :null
Both singleton are same

casos Aqui Singleton criados por threadA e threadB são os mesmos. Significa threadB está à espera fora até threadA liberá-lo do bloqueio.

Agora, mudar o Singleton.java comentando Thread.sleep (500); método e descomentando Singleton.class.wait (500); . Aqui por causa de Singleton.class.wait (500); método threadA vai liberar todos os bloqueios adquirir e se move para o estado “Non Runnable”, threadB vai começar a mudança para entrar no bloco sincronizado.

Agora execute novamente:

SingletonA still null
SingletonA still null
SingletonA still null
_instance :com.omt.sleepwait.Singleton@10c042ab
SingletonA still null
SingletonA still null
SingletonA still null
Both singleton are not same

casos Aqui Singleton criados por threadA e threadB não são mesmo por causa da threadB tem troco para entrar no bloco sincronizado e depois de 500 milissegundos threadA iniciados a partir de sua última posição e criou um objeto mais Singleton.

Answer 26

deve ser chamado de bloco sincronizado: método wait() é sempre chamado de bloco sincronizado ou seja wait() necessidades método para monitor objeto bloqueio antes de objeto no qual ele é chamado. Mas o método sleep() pode ser chamado de fora sincronizado bloco método ou seja sleep() não precisa de qualquer monitor objeto.

IllegalMonitorStateException:. se o método wait() é chamado sem adquirir bloqueio objeto de IllegalMonitorStateException é jogado em tempo de execução, mas o método sleep() não joga tal exceção

Pertence a qual classe: método wait() pertence à classe java.lang.Object mas o método sleep() pertence à classe java.lang.Thread

.

Chamado no objeto ou tópico:. método wait() é chamado em objetos, mas método sleep() é chamado em Threads não objetos

estado da linha: quando o método wait() é chamado no objeto, fio esse monitor Holded do objeto vai do estado executando para esperando e pode retornar ao estado executável somente quando notify() ou notifyAll() método é chamado no objeto. E depois enrosque horários agendador esse segmento para ir a partir do executável para executar o estado. quando sleep() é chamado no thread que vai de correr para estado de espera e pode retornar ao estado executável quando o tempo de sono é para cima.

Quando chamado de bloco sincronizado: quando o método é chamado wait() folhas de rosca o bloqueio objeto. Mas o método sleep() quando chamado de bloco sincronizado ou segmento método não deixa de bloqueio objeto.

Para mais Referência

Answer 27

A partir da página de documentação do Oracle em espera () método de Object:

public final void wait()

1. Faz com que o segmento atual aguardar até outro segmento chama o método notify() ou o método notifyAll() para este objeto. Em outras palavras, este método se comporta exatamente como se ele simplesmente executa a wait(0) chamada.
2. O thread atual deve próprio monitor deste objeto. A posse de rosca lançamentos deste monitor e espera até que outro notifica rosca segmentos de espera no monitor deste objeto para acordar
3. interrupções e wakeups espúrias são possíveis
4. Este método só deve ser chamado por um thread que é o proprietário do Monitor deste objeto

Este método lança

1. IllegalMonitorStateException -. Se o thread atual não é o proprietário do monitor do objeto

2. InterruptedException - se algum fio interrompido o thread atual antes ou durante o atual segmento estava esperando por uma notificação. O estado interrompido do segmento atual é apagada quando essa exceção é lançada.

A partir da página de documentação do Oracle em sleep () método de classe Thread:

public static void sleep(long millis)

1. Faz com que o thread atualmente em execução no sono (interrupção temporariamente a execução) para o número especificado de milissegundos, sujeito à precisão e exatidão dos temporizadores e programadores do sistema.
2. O fio faz propriedade não perder de quaisquer monitores.

Este método lança:

1. IllegalArgumentException - se o valor da millis é negativo

2. InterruptedException - se alguma discussão interrompeu o segmento atual. O estado interrompido do segmento atual é apagada quando essa exceção é lançada.

Outra diferença fundamental:

wait() é um método não-estático (método de instância), ao contrário sleep() método estático (método de classe).

Answer 28

wait() é dado dentro de um método sincronizado Considerando sleep() é dado dentro de um método não sincronizada porque método wait() libertar o bloqueio sobre o objecto, mas sleep() ou yield() não solte o lock().

Answer 29

espera com um valor de tempo limite pode wakeup sobre valor limite esgotou ou notificar o que ocorrer primeiro (ou interromper bem), ao passo que, um sono acorda no valor de tempo limite esgotou ou interrupção o que ocorrer primeiro. wait () sem valor de tempo limite vai esperar para sempre até ser notificado ou interrompido

Answer 30

• O método wait(1000) faz com que o segmento atual para dormir até um segundo .
  • Um fio conseguia dormir menos de 1 segundo, se ele recebe o notify() ou notifyAll() chamada de método.
• A chamada para sleep(1000) faz com que o segmento atual para dormir por exatamente um segundo .
  • Também fio de dormir não é titular bloquear qualquer recurso . Mas thread em espera faz.