Java 线程通信与线程的生命周期

待我称王封你为后i 2021-11-22 03:40 285阅读 0赞

### 一、并发同步 ###

**1、线程通信 -- 使用 synchronized 与 等待和唤醒机制**

线程通信：**不同的线程执行不同的任务，如果这些任务有某种关系，线程之间必须能够通信、协调完成工作.**

经典的生产者和消费者案例(Producer/Consumer):

![20190728140946415.png][]           ![20190728141131350.png][]          ![20190728142106661.png][]

分析生产者和消费者案例存在的问题:

建议在生产水果的名称和颜色之间以及在消费打印之前使用Thread.sleep(10); 使效果更明显.

**问题1：出现名称与颜色紊乱的情况.**

**解决方案**：只要保证在生产水果的名称和颜色的过程保持同步，中间不能被消费者线程进来取走数据.

可以使用同步代码块/同步方法/Lock机制来保持同步性.

// 共享资源--水果
    class ShareResource{
        private String name;
        private String colour;
    
        /**
         *  生产者向共享资源对象中存储数据
         * @param name  存储的名称
         * @param colour 存储的颜色
         */
        synchronized public void push(String name, String colour){
            this.name = name;
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.colour = colour;
        }
    
        /**
         * 消费者从共享资源对象中取出数据
         */
        synchronized public void popup(){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.name + "--" + this.colour);
        }
    }

**问题2：应该出现生产一个数据,消费一个数据，交替出现**

**解决方案**：得使用 等待和唤醒 机制.

// 共享资源--水果
    class ShareResource{
        private String name;
        private String colour;
        private boolean isEmpty = true; // 表示共享资源对象是否为空的状态
    
        /**
         *  生产者向共享资源对象中存储数据
         * @param name  存储的名称
         * @param colour 存储的颜色
         */
        synchronized public void push(String name, String colour){
            try {
                while(!isEmpty){ // 当前对象为不空时等待消费者来获取
                    // 使用同步锁对象来调用，表示当前线程释放同步锁，进入等待池，只能被其他线程所唤醒
                    this.wait();
                }
                this.name = name;
                Thread.sleep(10);
                this.colour = colour;
                isEmpty = false; // 设置共享资源中数据为空
                this.notify(); // 唤醒一个线程(消费者)，多个使用notifyAll()
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 消费者从共享资源对象中取出数据
         */
        synchronized public void popup(){
            try {
                while(isEmpty){ // 当前对象为空时等待生产者来生产
                    // 使用同步锁对象来调用，表示当前线程释放同步锁，进入等待池，只能被其他线程所唤醒
                    this.wait();
                }
                Thread.sleep(10);
                System.out.println(this.name + "--" + this.colour);
                isEmpty = true; // 设置共享资源中数据为空
                this.notify(); // 唤醒一个线程(生产者)，多个使用notifyAll()
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

**java.lang.Object 类提供了两类（等待和唤醒）用于线程通信的方法.**

wait()：执行该方法的线程对象释放同步锁,JVM把该线程存放到等待池中,等待其他的线程唤醒该线程.

notify()：执行该方法的线程唤醒在等待池中等待的任意一个线程,把线程转到锁池中等待.

notifyAll()：执行该方法的线程唤醒在等待池中等待的所有的线程,把线程转到锁池中等待.

**注意**：**上述方法只能被同步监听锁对象来调，否则报错 IllegalMonitorStateException异常.**

**同步锁池:**

同步锁一般都选择多个线程共同的资源对象.

当前生产者在生产数据时（先拥有同步锁），其他线程就在锁池中等待获取锁.

当线程执行完同步代码块时，就会释放同步锁，其他线程开始抢锁的使用权.

多个线程只有共享使用相同的一个对象时，多线程之间才有互斥效果，把这个用来做互斥的对象称之为 **同步监听对象/同步锁**.

**  同步锁对象可以选择任意类型的对象都可以，只需要保证多个线程使用的是相同锁对象即可.**

因为，只有同步监听锁对象才能调用 wait和 notify方法，所以，wait和 notify方法应该存在于Object类中，而不是Thread类中.

**2、线程通信 -- 使用Lock机制和Condition接口**

wait和notify方法，只能被同步监听锁对象来调用，否则报错 IllegalMonitorStateException异常.

而Lock机制根本就没有同步锁，也就没有自动获取锁和自动释放锁的概念。

因为没有同步锁，所以Lock机制不能调用wait和notify方法.

**解决方案：**Java5中提供了Lock机制的同时也提供了处理Lock机制的通信控制的Condition接口.

从Java5开始,可以:

1）使用Lock机制取代 synchronized代码块和 synchronized方法.

2）使用Condition接口对象的await,signal,signalAll方法取代Object类中的wait,notify,notifyAll方法.

**Condition接口提供一个使用实例**

**     **![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70][]

public class ThreadDemo {
        public static void main(String[] args) {
            // 创建生产者和消费者共同的资源对象
            ShareResource shareResource = new ShareResource();
    
            // 启动生产者线程
            new Thread(new Producer(shareResource)).start();
            // 启动消费者线程
            new Thread(new Consumer(shareResource)).start();
        }
    }
    // 共享资源--水果
    class ShareResource{
        private String name;
        private String colour;
        private boolean isEmpty = true; // 表示共享资源对象是否为空的状态
        private final Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
    
        /**
         *  生产者向共享资源对象中存储数据
         * @param name  存储的名称
         * @param colour 存储的颜色
         */
        public void push(String name, String colour){
            lock.lock(); // 获取锁
            try {
                while(!isEmpty){ // 当前对象为不空时等待消费者来获取
                    condition.await();
                }
                this.name = name;
                Thread.sleep(10);
                this.colour = colour;
                isEmpty = false; // 设置共享资源中数据为空
                condition.signal(); // 唤醒一个线程(消费者)，多个使用signalAll()
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock(); // 释放锁
            }
        }
    
        /**
         * 消费者从共享资源对象中取出数据
         */
        public void popup(){
            lock.lock(); // 获取锁
            try {
                while(isEmpty){ // 当前对象为空时等待生产者来生产
                    condition.await();
                }
                Thread.sleep(10);
                System.out.println(this.name + "--" + this.colour);
                isEmpty = true; // 设置共享资源中数据为空
                condition.signal(); // 唤醒一个线程(消费者)，多个使用signalAll()
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock(); // 释放锁
            }
        }
    }
    
    // 生产者
    class Producer implements  Runnable{
        // 共享资源对象
        private ShareResource shareResource = null;
    
        public Producer(ShareResource shareResource){
            this.shareResource = shareResource;
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                if(i % 2 == 0){
                    shareResource.push("苹果","红色");
                }else{
                    shareResource.push("柚子","橘黄色");
                }
            }
        }
    }
    // 消费者
    class Consumer implements Runnable{
        // 共享资源对象
        private ShareResource shareResource = null;
    
        public Consumer(ShareResource shareResource){
            this.shareResource = shareResource;
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                shareResource.popup();
            }
        }
    }

### 二、线程的生命周期 ###

生命周期：一个事物从出生的那一刻开始到最终死亡中间的整个过程。线程也是有生命周期的，也存在不同的状态的，状态相互之间的可转换。如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 1][]

线程对象的状态存放在Thread类的内部类(State)中：

**注意:**Thread.State类其实是一个枚举类，因为线程对象的状态是固定的，只有6种，此时使用枚举来表示是最恰当的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 2][]

有人又把阻塞状态、等待状态和计时等待状态合称为阻塞状态。如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 3][]

**1、新建状态(new)**

使用new创建一个线程对象，仅仅在堆中分配内存空间，在调用start方法之前；新建状态下，线程压根就没有启动，仅仅只是存在一个线程对象而已。

Thread t = new Thread(); //此时t就属于新建状态

当新建状态下的线程对象调用了start方法，此时从新建状态进入可运行状态.

线程对象的start方法只能调用一次，否则报错：IllegalThreadStateException异常。

**2、可运行状态(runnable)**

分成两种状态：ready和running。分别表示就绪状态和运行状态。

就绪状态：线程对象调用start方法之后，等待JVM的调度(此时该线程并没有运行)。

运行状态：线程对象获得JVM调度，如果存在多个CPU，那么允许多个线程并行运行。

**3、阻塞状态(blocked)**

正在运行的线程因为某些原因放弃CPU，暂时停止运行，就会进入阻塞状态。此时JVM不会给线程分配CPU，直到线程重新进入就绪状态，才有机会转到运行状态.

阻塞状态只能先进入就绪状态，而不能直接进入运行状态.

阻塞状态的两种情况:

1）当A线程处于运行过程时，试图获取同步锁时，却被B线程获取，此时JVM把当前A线程存到对象的锁池中，A线程进入阻塞状态.

2）当线程处于运行过程时，发出了IO请求时，此时进入阻塞状态.

**4、等待状态(waiting)**(等待状态只能被其他线程唤醒)：此时使用的无参数的wait方法,

当线程处于运行过程时，调用了wait()方法，此时JVM把当前线程存在对象等待池中.

**5、计时等待状态(timed waiting)**(使用了带参数的wait方法或者sleep方法)

1）当线程处于运行过程时，调用了wait(long time)方法，此时JVM把当前线程存在对象等待池中.

2）当前线程执行了sleep(long time)方法.

**6、终止状态(terminated)**：通常称为死亡状态，表示线程终止.

1）正常执行完run方法而退出(正常死亡).

2）遇到异常而退出(出现异常之后,程序就会中断)(意外死亡).

线程一旦终止，就不能再重启启动，否则报错：IllegalThreadStateException异常。

### 三、线程的控制操作 ###

**1、线程休眠：**让执行的线程暂停一段时间，进入**计时等待状态**。

方法：static void sleep(long millis)

调用sleep后，当前线程放弃CPU，在指定时间段之内，sleep所在线程不会获得执行的机会。此状态下的线程**不会释放同步锁/同步监听器。**该方法更多的用于模拟网络延迟，让多线程并发访问同一个资源的错误效果更明显，在开发中也会故意使用该方法。

线程的sleep方法应该写在线程的run()方法里，sleep()又是静态方法，所以最好的调用方法就是 **Thread.sleep()。**

注意：sleep方法只能让当前线程睡眠。调用某一个线程类的对象t.sleep()，睡眠的不是t，而是当前线程。

public static void main(String[] args) throws InterruptedException{
            for (int i = 10; i >0; i--) {
                System.out.println("剩余"+ i + "秒");
                Thread.sleep(1000);
            }
            System.out.println("Boom....");
        }

java.util.concurrent.TimeUnit也可以控制线程睡眠：

> TimeUnit.SECONDS.sleep(1);  
> TimeUnit.MINUTES.sleep(1);  
> TimeUnit.HOURS.sleep(1);  
> TimeUnit.DAYS.sleep(1);

**2、联合线程:**

方法：void join()  ：表示一个线程等待另一个线程（这个join的线程）完成后才执行。

join方法被调用之后，线程对象处于**阻塞状态**。

主要作用就是同步，它可以使得线程之间的并发执行变为串行执行。有人也把这种方式称为联合线程，就是说把当前线程和当前线程所在的线程联合成一个线程。

**注意：**join方法必须在线程start方法调用之后调用才有意义。如果一个线程都没有start，那它也就无法同步了。

**    比如：**在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行。

join方法中可以传入参数，如果A线程中调用B线程的join(10)，则表示A线程会等待B线程执行10毫秒，10毫秒过后，A、B线程并发执行。注意：jdk规定，join(0)的意思不是A线程等待B线程0秒，而是A线程等待B线程无限时间，直到B线程执行完毕，即join(0)等价于join()。

public class ThreadDemo {
        public static void main(String[] args) throws InterruptedException{
            System.out.println("begin....");
            JoinThread joinThread = new JoinThread();
            for (int i = 0; i < 15; i++) {
                System.out.println("main " + i);
                if (i ==5 ) {
                    joinThread.start();//启动join线程
                }
                if (i == 10 ) {
                    joinThread.join(); //强制运行该线程,直到结束后运行另一个线程
                }
            }
            System.out.println("end...");
        }
    }
    //联合线程
    class JoinThread extends Thread {
        public void run() {
            for (int i = 0; i < 50; i++) {
                System.out.println("Join" + i);
            }
        }
    }

**3、后台线程：**

在后台运行的线程，其目的是为其他线程提供服务，也称为“守护线程"。JVM的垃圾回收线程就是典型的后台线程。

特点：**若所有的前台线程都死亡，后台线程自动死亡。反过来，如果后台线程先执行完，前台线程会不停止。**

方法：

boolean isDaemon() ；//测试这个线程是否是守护线程。

void setDaemon(boolean on) ;//将此线程标记为 daemon线程或用户线程。

前台线程创建的线程默认是前台线程，可以通过setDaemon方法设置为后台线程，并且当且仅当后台线程创建的新线程时，新线程是后台线程。

设置后台线程：thread.setDaemon(true)；该方法必须在start方法调用前，否则报错：IllegalThreadStateException异常。

public class ThreadDemo {
        public static void main(String[] args){
            //判断当前线程是否是守护线程
            System.out.println(Thread.currentThread().isDaemon()); // false
            for (int i = 0; i < 10; i++) {
                System.out.println("main " +i);
                if(i == 5){
                    DaemomThread dt =new DaemomThread();
                    dt.setDaemon(true);//设置为后台线程,并且在调用start之前设置
                    dt.start();
                }
                //当前台线程结束之后.后台线程也会相应的自动结束
            }
        }
    }
    //后台线程
    class DaemomThread extends Thread{
        public void run(){
            for (int i = 0; i <133; i++) {
                System.out.println(super.getName()+ "  " + i);
                //System.out.println(Thread.currentThread().isDaemon());
    
            }
        }
    }

**4、线程优先级（1-10）:**

每个线程都有优先级，优先级的高低只和线程获得执行机会的次数多少有关，并非线程优先级越高的就一定先执行，哪个线程的先运行取决于CPU的调度。

MAX\_PRIORITY=10,最高优先级

MIN\_PRIORITY=1,最低优先级

NORM\_PRIORITY=5,默认优先级

方法：

int getPriority() ; //返回此线程的优先级

void setPriority(int newPriority) ;//更改此线程的优先级。

每个线程都有默认优先级，主线程默认优先级为5，如果A线程创建了B线程，那么B线程和A线程具有相同优先级。

注意：不同的操作系统支持的线程优先级不同的，建议使用上述三个常量优先级就够了，不要自定义。

public class ThreadDemo {
        public static void main(String[] args){
            //设置当前线程的优先级
            Thread.currentThread().setPriority(8);
            //获取当前的线程的优先级级别
            System.out.println(Thread.currentThread().getPriority()); // 8
            PriorityThread max = new PriorityThread("高优先级");
            max.setPriority(Thread.MAX_PRIORITY);
            PriorityThread min = new PriorityThread("低优先级");
            min.setPriority(Thread.MIN_PRIORITY);
            min.start();
            max.start();
        }
    }
    class PriorityThread extends Thread{
        public PriorityThread(String name){
            super(name);//调用父类的构造器
        }
        @Override
        public void run(){
            for (int i = 0; i < 10; i++) {
                System.out.println(super.getName() +  "-" + i);
            }
        }
    }

**5、线程礼让:**

static void yield() 方法：表示当前线程对象提示调度器自己愿意让出CPU资源，但是调度器可以自由的忽略该提示。

调用该方法之后，线程对象进入**就绪状态**，所以完全有可能某个线程调用了yield()之后,线程调度器又把它调度出来重新执行。

从 Java7 提供的文档上可以清楚的看出，开发中很少会使用到该方法，该方法主要用于调试或测试，它可能有助于因多线程竞争条件下的错误重现现象。

public class ThreadDemo {
        public static void main(String[] args){
            YieldThread max = new YieldThread("高优先级");
            max.setPriority(Thread.MAX_PRIORITY);
            YieldThread min = new YieldThread("低优先级");
            min.setPriority(Thread.MIN_PRIORITY);
            min.start();
            max.start();
        }
    }
    class YieldThread extends Thread{
        public YieldThread(String name){
            super(name);//调用父类的构造器
        }
        @Override
        public void run(){
            for (int i = 0; i < 100; i++) {
                System.out.println(super.getName() +  "-" + i);
                if(i ==20){
                    Thread.yield();//当i=20的时候,做出礼让 (效果不明显)
                }
            }
        }
    }

sleep方法和yield方法的区别:

1）都能使当前处于运行状态的线程放弃CPU，把运行的机会给其他线程.

2）sleep方法会给其他线程运行机会，但是不考虑其他线程的优先级，yield方法只会给相同优先级或者更高优先级的线程运行的机会.

3）调用sleep方法后，线程进入计时等待状态，调用yield方法后，线程进入就绪状态.

**6、线程中断方法**

1）interrupt()方法，作用于调用者线程

表示中断此线程（指调用该方法的Thread实例所代表的线程），但实际上只是给线程设置一个中断标志，线程仍会继续运行。

2）isInterrupted()方法，作用于调用者线程

表示测试此线程（调用者代表的线程）是否已经中断，不清除中断状态。

3）interrupted() 静态方法，作用于当前线程

表示测试当前线程是否已经中断并清除中断状态（中断标志），有中断标记的话，返回一个ture并清除中断状态，第二次再调用时中断状态已经被清除，则返回一个false。

public class InterruptDemo {
    
        public static void main(String[] args) {
            Thread threadDemo = new Thread(new ThreadDemo());
            threadDemo.start();
            // 给 threadDemo打中断标记
            threadDemo.interrupt();
            // 此线程：threadDemo
            System.out.println(threadDemo.isInterrupted()); // true
            System.out.println(threadDemo.isInterrupted()); // true
            System.out.println("线程是否存活" + threadDemo.isAlive()); // true
    
            // 当前线程：main线程 无标记
            System.out.println(Thread.interrupted()); // fasle
            // 给当前线程打中断标记
            Thread.currentThread().interrupt();
            System.out.println(Thread.interrupted()); // true
            System.out.println(Thread.interrupted()); // fasle
        }
    
        private static class ThreadDemo implements Runnable{
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + "==" + i);
                }
            }
        }
    }

interrupt()只是打标记，若想要是实现调用interrupt()方法真正的终止线程，则可以在线程的run方法中做处理即可，比如直接跳出run()方法使线程结束。

private static class ThreadDemo implements Runnable{
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + "==" + i);
                    if(Thread.currentThread().isInterrupted()){
                        return;
                    }
                }
            }
        }

**7、定时器和线程组**

**1、定时器**

在JDK的java.util包中提供了Timer类,可以定时执行特定的任务.

TimerTask子类表示定时器执行的某一项任务.

常用方法:

void schedule(TimerTask task, Date firstTime, long period) ;//从指定 的时间开始 ,对指定的任务执行重复的 固定延迟执行 。

void schedule(TimerTask task, long delay) ;//在指定的延迟之后安排指定的任务执行。

void cancel();// 终止此计时器，丢弃任何当前计划的任务。

public class ThreadDemo {
        public static void main(String[] args){
            System.out.println("begin...");
            Timer timer = new Timer();
            for (int i = 0; i < 5; i++) {
                //此处Timer必须设置为前台线程,否则看不到效果
                //timer.schedule(new PrintDemo(), 3000);
            }
            System.out.println("end...");
            //timer.cancel();//终止此计时器
            
            // 只是用一次，可以用匿名内部类
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println(new Date().toLocaleString());
                }
            }, 2000,1000);
        }
    }
    //定时器
    class PrintDemo extends TimerTask {
        @Override
        public void run(){
            //在3秒之后打印内容5次
            System.out.println("五一节快乐~");
        }
    }

**2、线程组**

ThreadGroup类表示线程组，可以对一组线程进行集中管理.

用户在创建线程对象时，可以通过构造器指定其所属的线程组.

构造器：Thread(ThreadGroup group, String name) ;//分配一个新的 Thread对象。

如果A线程创建了B线程，如果没有设置B线程的分组，那么B线程加入到A线程的线程组.

一旦线程加入某个线程组，该线程就一直存在于该线程组中直到线程死亡，不能在中途修改线程的分组.

当Java程序运行时，JVM会创建名为main的线程组，在默认情况下，所有的线程都是该在线程组下.

ends ~

[20190728140946415.png]: https://img-blog.csdnimg.cn/20190728140946415.png
[20190728141131350.png]: https://img-blog.csdnimg.cn/20190728141131350.png
[20190728142106661.png]: /images/20211122/5ac10ea573ee4f619f7d39d0dec08168.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70]: /images/20211122/573dc6dd5eba4d789555d193087e314c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 1]: /images/20211122/c03c93f645444c05a65353aee971042b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 2]: /images/20211122/3b0ddcefb8cf4257b36a372b4cd465fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 3]: /images/20211122/e7474647d5b84368a67efd39a17908bd.png