Java线程状态和等待唤醒机制和线程池的实现代码

本篇文章小编给大家分享一下Java线程状态和等待唤醒机制和线程池的实现代码，文中代码介绍的很详细，小编觉得挺不错的，现在分享给大家供大家参考，有需要的小伙伴们可以来看看。

1.概念

线程一共有6中状态，相互之间可以互相转换。

等待唤醒案例（线程之间的通信）

实现:

等待唤醒案例:线程之间的通信

创建一个顾客线程(消费者):告知老板要的包子的种类和数量,调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)

创建一个老板线程(生产者):花了5秒做包子,做好包子之后,调用notify方法,唤醒顾客吃包子

注意:

顾客和老板线程必须使用同步代码块包裹起来,保证等待和唤醒只能有一个在执行

同步使用的锁对象必须保证唯一

只有锁对象才能调用wait和notify方法

Obejct类中的方法

void wait()

在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。

void notify()

唤醒在此对象监视器上等待的单个线程。

会继续执行wait方法之后的代码

进入到TimeWaiting(计时等待)有两种方式

1.使用sleep(long m)方法,在毫秒值结束之后,线程睡醒进入到Runnable/Blocked状态

2.使用wait(long m)方法,wait方法如果在毫秒值结束之后,还没有被notify唤醒,就会自动醒来,线程睡醒进入到Runnable/Blocked状态

唤醒的方法:

void notify() 唤醒在此对象监视器上等待的单个线程。

void notifyAll() 唤醒在此对象监视器上等待的所有线程。

public static void main(String[] args) {
  //创建锁对象,保证唯一
  final Object obj = new Object();
  // 创建一个顾客线程(消费者)
  new Thread(){
    @Override
    public void run() {
      //一直等着买包子
      while(true){
        //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
        synchronized (obj){
          System.out.println("顾客1告知老板要的包子的种类和数量");
          //调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
          try {
            obj.wait();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          //唤醒之后执行的代码
          System.out.println("包子已经做好了,顾客1开吃!");
          System.out.println("---------------------------------------");
        }
      }
    }
  }.start();

  // 创建一个顾客线程(消费者)
  new Thread(){
    @Override
    public void run() {
      //一直等着买包子
      while(true){
        //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
        synchronized (obj){
          System.out.println("顾客2告知老板要的包子的种类和数量");
          //调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
          try {
            obj.wait();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          //唤醒之后执行的代码
          System.out.println("包子已经做好了,顾客2开吃!");
          System.out.println("---------------------------------------");
        }
      }
    }
  }.start();

  //创建一个老板线程(生产者)
  new Thread(){
    @Override
    public void run() {
      //一直做包子
      while (true){
        //花了5秒做包子
        try {
          Thread.sleep(5000);//花5秒钟做包子
        } catch (InterruptedException e) {
          e.printStackTrace();
        }

        //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
        synchronized (obj){
          System.out.println("老板5秒钟之后做好包子,告知顾客,可以吃包子了");
          //做好包子之后,调用notify方法,唤醒顾客吃包子
          //obj.notify();//如果有多个等待线程,随机唤醒一个
          obj.notifyAll();//唤醒所有等待的线程
        }
      }
    }
  }.start();
}

2.等待唤醒机制

就是在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将其唤醒notify();在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。

等待唤醒中的方法 ：

wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中

notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先入座。

notifyAll：则释放所通知对象的 wait set 上的全部线程。

3.线程池

线程池其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

Java里面线程池的顶级接口是java.util.concurrent.Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService。 要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。

使用：

线程池:JDK1.5之后提供的

java.util.concurrent.Executors:线程池的工厂类,用来生成线程池

Executors类中的静态方法:

static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池

参数:

int nThreads:创建线程池中包含的线程数量

返回值:

ExecutorService接口,返回的是ExecutorService接口的实现类对象,我们可以使用ExecutorService接口接收(面向接口编程)

java.util.concurrent.ExecutorService:线程池接口

用来从线程池中获取线程,调用start方法,执行线程任务

submit(Runnable task) 提交一个 Runnable 任务用于执行

关闭/销毁线程池的方法

void shutdown()

线程池的使用步骤:

1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池

2.创建一个类,实现Runnable接口,重写run方法,设置线程任务

3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法

4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)

例子:

public class RunnableImpl implements Runnable{
  @Override
  public void run() {
    System.out.println(Thread.currentThread().getName()+"创建了一个新的线程执行");
  }
}
 
public static void main(String[] args) {
  //1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
  ExecutorService es = Executors.newFixedThreadPool(2);
  //3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
  es.submit(new RunnableImpl());//pool-1-thread-1创建了一个新的线程执行
  //线程池会一直开启,使用完了线程,会自动把线程归还给线程池,线程可以继续使用
  es.submit(new RunnableImpl());//pool-1-thread-1创建了一个新的线程执行
  es.submit(new RunnableImpl());//pool-1-thread-2创建了一个新的线程执行

  //4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
  es.shutdown();

  es.submit(new RunnableImpl());//抛异常,线程池都没有了,就不能获取线程了
}