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());//抛异常,线程池都没有了,就不能获取线程了
}

到此这篇关于Java 线程状态和等待唤醒机制和线程池的实现的文章就介绍到这了,更多相关Java 线程状态和等待唤醒机制 内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！