java线程的生命周期及wait(),notify(),notifyAll()的详解分析

我就是我 2022-08-19 04:46 7阅读 0赞

**1.java线程的生命周期**  
 线程是一个动态执行的过程，它也有一个从产生到死亡的过程。

(1)生命周期的五种状态

**新建（new Thread）**  
 当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）。  
例如：Thread t1=new Thread();

**就绪（runnable）**  
 线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。例如：**t1.start();**

**运行（running）**  
 线程获得CPU资源正在执行任务（run()方法），此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入，线程将一直运行到结束。

**死亡（dead）**  
 当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。

自然终止：正常运行run()方法后终止

异常终止：调用方法stop()让一个线程终止运行

**堵塞（blocked）**  
由于某种原因导致正在运行的线程让出CPU并暂停自己的执行，即进入堵塞状态。

正在睡眠：用sleep(long t) 方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。

正在等待：调用wait()方法。（调用motify()方法回到就绪状态）

被另一个线程所阻塞：调用suspend()方法。（调用resume()方法恢复）

**2.常用方法**

setPriority( ) 设置线程的优先权;

void run() 创建该类的子类时必须实现的方法

void start() 开启线程的方法

static void sleep(long t) 释放CPU的执行权，不释放锁

final void wait() 释放CPU的执行权，释放锁。类似sleep( ), 不同的是，wait( )会先释放锁住的对象，然后再执行等待的动作。注意，这个函数属于 Object类。另外，由于wait( )所等待的对象必须先锁住，因此，它只能用在同步化程序段或者同步化方法内，否则，会抛出异 常IllegalMonitorStateException.

final void notify() 唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程(随机)。直到当前的线程 放弃此对象上的锁，才能继续执行被唤醒的线程。同Wait方法一样，notify只能由持有对像锁的线程来调用.notifyall也一样，不 同的是notifyall会唤配所有在此对象锁上等待的线程。"只能由持有对像锁的线程来调用"说明wait方法与notify方法必须在同步块

内执行,即synchronized(obj)之内.再者synchronized代码块内没有锁是寸步不行的，所以线程要继续执行必须获得锁,相辅相成.

join( ): 等待加入的线程执行完毕才会执行下一个线程。加入的线程通过interrupt( )来唤醒。

static void yied()暂停线程的执行，给其它具有相同优先权的线程执行的机会，若此时没有其它线程执行，则此线程继续执行。这个函数并不会释 放锁住的对象。

wait导致当前的线程等待，直到其他线程调用此对象的 **notify()** 方法或 **notifyAll()** 方法,或被其他线程中断。wait只能由持有对像锁的线程来调用。

**注意：**

**wait(),notify(),notifyAll()**不属于**Thread类**,而是属于**Object基础类**,也就是说每个对象都有**wait(),notify(),notifyAll()的功能**.因为每个对象都有锁,锁是每个对象的基础,当然操作锁的方法也是最基础了。

**3.wait(),notify(),notifyAll()的详解分析**

很经典的例子(生产者与消费者):  
首先是消费者线程类：

import java.util.List;  
    public class Consume implements Runnable {  
     private List container = null;  
     private int count;  
     public Consume(List lst) {  
      this.container = lst;  
     }  
     public void run() {  
      while (true) {  
       synchronized (container) {  
        if (container.size() == 0) {  
         try {  
          container.wait();// 容器为空，放弃锁，等待生产  
         } catch (InterruptedException e) {  
          e.printStackTrace();  
         }  
        }  
        try {  
         Thread.sleep(1000);  
        } catch (InterruptedException e) {  
         e.printStackTrace();  
        }  
        container.remove(0);  
        container.notify();  
        System.out.println("我吃了" + (++count) + "个");  
       }  
      }  
     }  
    }

接下来是生产者线程类：

import java.util.List;
    public class Product implements Runnable {
     private List container = null;
     private int count;
     public Product(List lst) {
      this.container = lst;
     }
     public void run() {
      while (true) {
       synchronized (container) {
        if (container.size() > MultiThread.MAX) {
         // 如果容器超过了最大值，就不要在生产了，等待消费
         try {
          container.wait();
         } catch (InterruptedException e) {
          e.printStackTrace();
         }
        }
        try {
         Thread.sleep(1000);
        } catch (InterruptedException e) {
         e.printStackTrace();
        }
        container.add(new Object());
        container.notify();
        System.out.println("我生产了" + (++count) + "个");
       }
      }
     }
    }

最后是测试类：

import java.util.ArrayList;
    import java.util.List;
    public class MultiThread {
     private List container = new ArrayList();
     public final static int MAX = 10;
     public static void main(String args[]) {
      MultiThread m = new MultiThread();
      new Thread(new Consume(m.getContainer())).start();
      new Thread(new Product(m.getContainer())).start();
     }
     public List getContainer() {
      return container;
     }
     public void setContainer(List container) {
      this.container = container;
     }
    }

运行结果如下所示：

我生产了1个
    我吃了1个
    我生产了2个
    我生产了3个
    我生产了4个
    我生产了5个
    我生产了6个
    我生产了7个
    我吃了2个
    我生产了8个
    我吃了3个
    我生产了9个
    我吃了4个
    我吃了5个
    我吃了6个
    我吃了7个
    我吃了8个
    我生产了10个
    我生产了11个
    我吃了9个
    我生产了12个
    我吃了10个

......