这篇文章将为大家详细讲解有关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的优点是什么

1. 简单，只需理解基本的概念，就可以编写适合于各种情况的应用程序；2. 面向对象；3. 分布性，Java是面向网络的语言；4. 鲁棒性，java提供自动垃圾收集来进行内存管理，防止程序员在管理内存时容易产生的错误。；5. 安全性，用于网络、分布环境下的Java必须防止病毒的入侵。6. 体系结构中立，只要安装了Java运行时系统，就可在任意处理器上运行。7. 可移植性，Java可以方便地移植到网络上的不同机器。8.解释执行，Java解释器直接对Java字节码进行解释执行。

关于“Java中线程状态和等待唤醒机制和线程池的实现方法”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，使各位可以学到更多知识，如果觉得文章不错，请把它分享出去让更多的人看到。

当前文章：Java中线程状态和等待唤醒机制和线程池的实现方法
当前路径：http://lswzjz.com/article/pcsphc.html