Java多线程阻止和唤醒代码示例

阻塞和唤醒Java线程

1. sleep（）方法:

sleep（...毫秒），以毫秒为单位指定时间，以便线程在此时间内进入线程阻塞状态，在此期间无法获取cpu的任何时间片. 时间过去后，线程将重新进入可执行状态. （线程已暂停，锁未释放）

//测试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();
  }

2.suspend（）和resume（）方法: .

挂起并唤醒线程. pause（）使线程进入阻塞状态. 仅当调用相应的resume（）时，线程才会进入可执行状态. （不推荐，容易死锁）

//测试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();
}

（控制台打印出来后，它将暂停2秒钟，然后继续打印. ）

3. Yield（）方法:

该线程将放弃当前的CPU时间片，但是此时线程仍处于可执行状态，您可以随时再次获取CPU时间片. yield（）方法只能为相同优先级的线程提供执行的机会. 调用yield（）的效果等同于调度程序认为线程已执行了足够的时间转到另一个线程. （暂停当前正在执行的线程，并执行其他线程，并且给定的时间未知）

//测试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
……
*/

（可以看出多线程阻塞状态，当数字为33时，会有一个交替. ）

4.wait（）和notify（）方法:

这两种方法一起使用. wait（）使线程进入阻塞状态. 调用notify（）时，线程进入可执行状态. 您可以在wait（）中添加或不添加参数. 参数以毫秒为单位添加. 当达到指定时间或调用notify（）方法时，进入可执行状态. （属于Object类，而不是Thread类，wait（）将首先释放锁定的对象，然后执行等待操作. 由于必须首先锁定由wait（）等待的对象，因此只能用于同步在程序段或同步方法内，否则将抛出异常IllegalMonitorStateException. ）

//测试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();
}

5.join（）方法

也称为线程连接. 它是当前线程A调用另一个线程B的join（）方法. 当前线程将A变为阻塞状态. 直到线程B的运行结束，线程A才从阻塞状态变为可执行状态.

//测试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'm Main线程");
}
/*
运行结果为：
Start Progress.
Thread11线程 : 0
Thread11线程 : 1
Thread11线程 : 2
Thread11线程 : 3
Thread11线程 : 4
End Progress.
hi,I'm Main线程
*/

摘要

本文介绍了Java多线程阻塞和唤醒代码示例多线程阻塞状态，希望对大家学习Java有所帮助. 有兴趣的朋友可以继续参考: Java多线程ForkJoinPool实例的详细说明，通过票证了解Java多线程，Java线程安全基本概念分析等. 如果有任何疑问，可以随时留言，或者，如果您想了解一些信息，也可以留言. 编辑会及时回复您. 希望大家都支持Script House！

本文来自电脑杂谈，转载请注明本文网址：
https://www.pc-fly.com/a/ruanjian/article-246479-1.html