Exemple de code pour le blocage et le réveil multi-thread en Java

Cet article partage principalement avec vous le contenu pertinent sur le blocage et la réactivation dans le multi-threading Java. Grâce à cet article, vous pouvez comprendre approximativement les méthodes d'entrée dans l'état de blocage des threads et l'état de l'exécutable. Les amis qui en ont besoin peuvent en apprendre davantage. il.

Blocage et réveil du fil Java

Méthode sleep() :

sommeil (...millisecondes), spécifie le temps en millisecondes, de sorte que le thread entre dans l'état de blocage de thread pendant ce temps, pendant lequel la tranche de temps CPU n'est pas obtenue. Lorsque le temps passe, le thread rentre dans l'état exécutable. (En suspendant le fil de discussion, le verrou ne sera pas libéré)

//测试sleep（）方法
class Thread7 implements Runnable{
  @Override
  public void run() {
    for(int i=0;i<50;i++){
      System.out.println(Thread.currentThread().getName()+"num="+i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}
class Thread8 implements Runnable{
  @Override
  public void run() {
    for(int i=0;i<1000;i++){
      System.out.println(Thread.currentThread().getName()+"num="+i);
    }
  }
}
public static void main(String[] args) {
    /*
     * 测试线程阻塞
     */
    //测试sleep（）方法
    Thread7 t7=new Thread7();
    Thread8 t8=new Thread8();
    Thread t81=new Thread(t8, "饺子");
    Thread t71=new Thread(t7, "包子");
    Thread t72=new Thread(t7, "面包");
    t71.start();
    t81.start();
    t72.start();
  }

Méthodes 2.suspend() et curriculum vitae() :.

Suspendez et réveillez le thread. suspend() met le thread dans l'état de blocage. Le thread n'entrera dans l'état exécutable que lorsque la reprise() correspondante sera appelée. (Non recommandé, un blocage est susceptible de se produire)

//测试suspend（）和resume（）方法
class Thread9 implements Runnable{
  @Override
  public void run() {
    for(long i=0;i<500000000;i++){
System.out.println(Thread.currentThread().getName()+" num= "+i);
    }
  }
}
public static void main(String[] args) {
  //测试suspend和resume
    Thread9 t9=new Thread9();
    Thread t91=new Thread(t9,"包子");
    t91.start();
    try {
      Thread.sleep(2000);
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    t91.suspend();
    try {
      Thread.sleep(2000);
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    t91.resume();
}

(Lorsque la console imprime la sortie, elle s'arrête pendant 2 secondes, puis continue l'impression.)

3. Méthode rendement() :

entraînera l'abandon par le thread de la tranche de temps CPU actuelle, mais le thread est toujours dans l'exécutable. Dans cet état, la tranche de temps CPU peut être réattribuée à tout moment. La méthode rendement() ne peut donner qu’une chance d’exécution aux threads de même priorité. L'effet de l'appel de rendement() équivaut à ce que le planificateur considère que le thread a exécuté suffisamment de temps pour passer à un autre thread. (Mettez en pause le thread en cours d'exécution et exécutez d'autres threads, et le temps indiqué est inconnu)

//测试yield（）方法
class Thread10 implements Runnable{
  @Override
  public void run() {
    for(int i=0;i<100;i++){
      System.out.println(Thread.currentThread().getName()+" num= "+i);
      if(i==33){
        Thread.yield();
      }
    }
  }
}

public static void main(String[] args) {
  //测试yield
    Thread10 t10 =new Thread10();
    Thread t101=new Thread(t10, "包子");
    Thread t102=new Thread(t10, "面包");
    t101.start();
    t102.start();
}
/*
运行结果为：
……
包子 num= 24
包子 num= 25
包子 num= 26
包子 num= 27
包子 num= 28
包子 num= 29
包子 num= 30
包子 num= 31
包子 num= 32
包子 num= 33
面包 num= 0
面包 num= 1
面包 num= 2
面包 num= 3
……
面包 num= 30
面包 num= 31
面包 num= 32
面包 num= 33
包子 num= 34
包子 num= 35
包子 num= 36
包子 num= 37
包子 num= 38
……
*/

(Comme vous pouvez le voir, lorsque le nombre est 33, l'alternance a )

Méthodes 4.wait() et notify() :

Utilisez les deux méthodes ensemble, wait() Mettez le fil dans l'état de blocage. Lorsque notify() est appelé, le thread entre dans l'état exécutable. Vous pouvez ajouter ou non des paramètres dans wait(). Lors de l'ajout de paramètres, l'unité est en millisecondes. Lorsque le temps spécifié est atteint ou que la méthode notify() est appelée, elle entre dans l'état exécutable. (Appartenant à la classe Object et non à la classe Thread, wait() libérera d'abord l'objet verrouillé, puis effectuera l'action d'attente. Puisque l'objet attendu par wait() doit être verrouillé en premier, il ne peut être utilisé que pour la synchronisation. . segment de programme ou méthode synchronisée, sinon, une exception IllegalMonitorStateException sera levée.)

//测试wait（）和notify（）方法
//用生产者和消费者模式模拟这一过程
/*消费者 */
class Consumer implements Runnable {
private Vector obj;
  public Consumer(Vector v) {
    this.obj = v;
  }
  public void run() {
    synchronized (obj) {
      while (true) {
        try {
          if (obj.size() == 0) {
            obj.wait();
          }
          System.out.println("消费者：我要买面包。");
          System.out.println("面包数： " + obj.size());
          obj.clear();
          obj.notify();
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    }
  }
}
/* 生产者 */
class Producter implements Runnable {
  private Vector obj;
  public Producter(Vector v) {
    this.obj = v;
  }
  public void run() {
    synchronized (obj) {
      while (true) {
        try {
          if (obj.size() != 0) {
            obj.wait();
          }
          obj.add(new String("面包"));
          obj.notify();
          System.out.println("生产者：面包做好了。");
          Thread.sleep(500);
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    }
  }
}
public static void main(String[] args) {
  //测试wait（）和notify（）
    Vector obj = new Vector();
    Thread consumer = new Thread(new Consumer(obj));
    Thread producter = new Thread(new Producter(obj));
    consumer.start();
    producter.start();
}

Méthode 5.join()

Également appelé adhésion à un fil de discussion. Le thread actuel A appelle la méthode join() d'un autre thread B. Le thread actuel A entre dans l'état de blocage ce n'est que lorsque le thread B a fini de s'exécuter que le thread A passe de l'état de blocage à l'état exécutable.

//测试join
class Thread11 implements Runnable{
  @Override
  public void run() {
    System.out.println("Start Progress.");
    try {
      for(int i=0;i<5;i++){
        System.out.println("Thread11线程 : "+i);
        Thread.sleep(1000);
      }
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    System.out.println("End Progress.");
  }
}
public static void main(String[] args) {
  //测试join
    Thread11 t11=new Thread11();
    Thread t111=new Thread(t11);
    t111.start();
    try {
      t111.join();
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    System.out.println("hi,I&#39;m Main线程");
}
/*
运行结果为：
Start Progress.
Thread11线程 : 0
Thread11线程 : 1
Thread11线程 : 2
Thread11线程 : 3
Thread11线程 : 4
End Progress.
hi,I&#39;m Main线程
*/

Résumé

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!