Come funziona il metodo sleep() sul dato thread e output?

Question

Capisco che sleep() venga utilizzato per interrompere una discussione per un periodo di tempo specificato. Ho creato degli esempi di rimorchio: nell'esempio 1 ho ottenuto l'output come 1, 2, 3, 4 perché ne ho creato uno solo. Nell'esempio 2, ho creato 2 istanze del thread e ottengo l'output 1, 1, 2, 2, 3, 3, 4, 4.

Perché l'uscita non è 1, 2, 3, 4 per il primo filetto seguita da 1, 2, 3, 4 per la seconda ?.

Esempio 1:

// Using sleep() method 
    public class Aaa extends Thread{ 
    public void run(){ 
     for(int i=1;i<5;i++){ 
     try{ 
      Thread.sleep(500); 
     } catch(InterruptedException e){ 
      System.out.println(e); 
     } 
     System.out.println(i); 
     } 
    } 
    public static void main(String[] args){ 
     Aaa m1=new Aaa(); 
     m1.start(); 
    } 
    } 

Output: 
    1 
    2 
    3 
    4 

Esempio 2:

// Using sleep() method 
    public class Aaa extends Thread{ 
    public void run(){ 
     for(int i=1;i<5;i++){ 
     try{ 
      Thread.sleep(500); // sleeps thread 
     } catch(InterruptedException e){ 
      System.out.println(e); 
     } 
     System.out.println(i); 
     } 
    } 
    public static void main(String[] args){   
     Aaa m1=new Aaa(); // creating one object 
     Aaa m2=new Aaa(); // creating second object of a class 
     m1.start(); // calls run method 
     m2.start(); 
    } 
    } 


Output: 
    1 
    1 
    2 
    2 
    3 
    3 
    4 
    4 

Answer 1

Sono stati creati due oggetti Runnable. Se li si esegue chiamando il loro metodo run si otterrebbe quello che si immagina:

Aaa m1=new Aaa(); // creating one object 
    Aaa m2=new Aaa(); // creating second object of a class 
    System.out.println("Calling m1.run()"); 
    m1.run(); // we call run method 
    System.out.println("Calling m2.run()"); 
    m2.run(); 

uscita

Calling m1.run() 
1 
2 
3 
4 
Calling m2.run() 
1 
2 
3 
4 

perché il metodo viene eseguito due volte, una dopo l'altra.

Si noti che la chiamata al metodo di un Runnable/Threadrun è non modo normale di eseguire un thread. Utilizzerai normalmente il metodo start.

Se, tuttavia, si mette ciascuno in un Thread e start loro:

Aaa m1=new Aaa(); // creating one object 
    Aaa m2=new Aaa(); // creating second object of a class 
    System.out.println("Calling m1.start()"); 
    m1.start(); // thread calls run method 
    System.out.println("Calling m2.start()"); 
    m2.start(); 

ciascun oggetto è ora gestito nel proprio thread parallelamente quindi l'uscita è intercalata:

Calling m1.start() 
Calling m2.start() 
1 < From thread 1 
1 < From thread 2 
2 ... 
2 
3 
3 
4 
4 

L'ordine potrebbe ovviamente variare a seconda di come i fili si intersecano.

Una cosa che potrebbe confonderti è che hai scelto di extend Thread. Questo è scoraggiato.E 'meglio implement Runnable - in questo modo:

public class Aaa implements Runnable { 
    public void run() { 
    for (int i = 1; i < 5; i++) { 
     try { 
     Thread.sleep(500); // sleeps thread 
     } catch (InterruptedException e) { 
     System.out.println(e); 
     } 
     System.out.println(i); 
    } 
    } 

    public static void main(String[] args) { 
    Aaa m1 = new Aaa(); // creating one object 
    Thread t1 = new Thread(m1); // Its thread 
    Aaa m2 = new Aaa(); // creating second object of a class 
    Thread t2 = new Thread(m2); // Its thread 
    t1.start(); // calls m's run method in a new thread. 
    t2.start(); 
    } 

} 

Ora è più chiaro che gli oggetti sono in esecuzione a due fili diversi e quindi eseguiti in parallelo.

Answer 2

Due fili stanno lavorando contemporaneamente - è il punto principale di utilizzo del filo. Se vuoi che qualcosa venga fatto non sul thread principale, ne lanci uno nuovo. O due se due compiti devono essere eseguiti e ognuno di loro lavora sul proprio thread non aspettando un altro.

Answer 3

m1 e m2 ottiene la stessa priorità dal thread principale e funziona contemporaneamente. sleep() consente al thread di passare allo stato di blocco per x millisecondi. Quando un thread entra nello stato di sospensione, non rilascia il blocco.

Answer 4

Per ottenere l'output desiderato 1,2, 3, 4, 1, 2, 3, 4, utilizzare il metodo join(). È possibile controllare l'esecuzione del thread utilizzando questo metodo.

Aaa m1=new Aaa(); // creazione di un oggetto
Aaa m2=new Aaa(); // creazione secondo oggetto di una classe
m1.start(); // chiama il metodo di esecuzione
m1.join();
m2.start();

Answer 5

sleep sospenderà l'esecuzione per il periodo di tempo specifico. Questo è il modo efficiente per rendere la CPU disponibile per altri thread da eseguire in parallelo. Il sonno non sbloccherà il lucchetto. Ma occorre fare attenzione che invocare il sonno non significa che il thread sarà sospeso per il tempo concesso.