2016-12-08 1 views
-1

Jusqu'à présent, je savais que l'attente toujours besoin de notification pour fonctionner correctement.Mais quand essayé le code ci-dessous je suis confus un peu sur le fonctionnement de wait et notify.I créé trois threads t1, t2, t3 et passé le runnable T1, T2 et T3 respectivement. Selon moi, quand j'ai commencé les trois threads, seulement t1 devrait imprimer et t2 et t3 devraient passer en attente et continuer à attendre car personne ne le signale.Attente toujours besoin d'aviser de travailler?

Mais l'o/p est imprévisible pour moi.Peut-être quelqu'un s'il vous plaît m'expulser un peu.Below sont mes classes.

package com.vikash.Threading; 

class T1 implements Runnable { 

    private State state; 

    public T1(State state) { 
     this.state=state; 
    } 

    @Override 
    public void run() { 

     synchronized (state) { 
      while(state.getState()!=1) { 
       try { 
        state.wait(); 
       } catch (InterruptedException e) { 
        e.printStackTrace(); 
       } 
      } 

      synchronized (state) { 
       System.out.println(Thread.currentThread().getName()); 
       state.setState(2); 
      } 
     } 
    } 
} 

class T2 implements Runnable { 

    private State state; 

    public T2(State state) { 
     this.state=state; 
    } 

    @Override 
    public void run() { 

     synchronized (state) { 
      while(state.getState()!=2) { 
       try { 
        state.wait(); 
       } catch (InterruptedException e) { 
        e.printStackTrace(); 
       } 
      } 

      synchronized (state) { 
       System.out.println(Thread.currentThread().getName()); 
       state.setState(3); 
      } 
     } 
    } 
} 

class T3 implements Runnable { 

    private State state; 

    public T3(State state) { 
     this.state=state; 
    } 

    @Override 
    public void run() { 

     synchronized (state) { 
      while(state.getState()!=3) { 
       try { 
        state.wait(); 
       } catch (InterruptedException e) { 
        e.printStackTrace(); 
       } 
      } 

      synchronized (state) { 
       System.out.println(Thread.currentThread().getName()); 
       state.setState(1); 
      } 
     } 
    } 
} 

public class Sequence { 

    public static void main(String[] args) { 

     State state=new State(); 
     Thread t1=new Thread(new T1(state),"First"); 
     Thread t2=new Thread(new T2(state),"Second"); 
     Thread t3=new Thread(new T3(state),"Third"); 
     t1.start(); 
     t2.start(); 
     t3.start(); 
    } 
} 



package com.vikash.Threading; 

public class State { 

    private int state=1; 

    public int getState() { 
     return state; 
    } 

    public void setState(int state) { 
     this.state = state; 
    } 
} 

Comme par commentaire que je suis en train de modifier ma question.Le o/p parfois je reçois d'abord seconde et il ne se termine pas et parfois Premier Deuxième Troisième et se terminent.

+1

S'il vous plaît expliquer * Mais l'o/p est imprévisible pour moi * –

+0

peut-être pas la raison, mais vous rendez-vous compte que vous avez imbriqué 'synchronized' voir http://stackoverflow.com/a/10365261/2310289 –

Répondre

2

Votre attente est incorrect, il est possible pour tous vos fils à imprimer et fin que votre programme est actuellement écrit (mais cela dépend de hasard)

Cela dépend de fil saisit le moniteur state en utilisant d'abord le bloc synchronized qu'ils ont tous.

Considérons ce flux:

  1. T1 pénètre dans le bloc synchronized (state) premier. T2 et T3 attendent d'entrer leurs blocs synchronized (state).
  2. T1 n'attend pas state.getState() == 1, donc au lieu
  3. T1 imprime le nom de fil et affecte 2-state.state
  4. T1 sort du bloc synchronisé
  5. Soit T2 ou T3 entrent dans leur bloc synchronized (state), supposons qu'il est T2 (que l'on entre d'abord est un comportement non défini en Java, et probable que ce soit au hasard)
  6. Alors T2 n'attend pas state.getState() == 2
  7. T2 imprime le nom de fil et affecte 3-state.state
  8. T2 quitte le bloc synchronisé
  9. T3 entre dans le bloc synchronisé, n'attend pas et imprime le nom du fil
  10. Programme exécuté.