Java 并发编程(二) 线程等待与唤醒

雨点打透心脏的1/2处 2022-10-02 03:57 178阅读 0赞

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][]

# 一. 前言 #

线程等待与唤醒主要是线程之间的通信,

分析了一下目前有三种,我们接着分析;

*  Object wait(),notify()
 *  Thread sleep(),interrupt()
 *  Condition await(),signal()

# 二. Object 的线程等待与唤醒 #

先举个例子在说话,省略类的外层了:

例1:

@Test
        public void test6() throws InterruptedException {
            Thread thread8 = new Thread(() -> {
                try {
                    synchronized (this){
                        LOG.info("wait");
                        this.wait();
                    }
                    LOG.info("wake up");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            thread8.start();
            Thread.sleep(3000);
            synchronized (this){
                LOG.info("wake up thread ");
                this.notify();
                Thread.sleep(2000);
            }
        }

例2:

private final static String SIGN = "sign";
    
        @Test
        public void test7() throws InterruptedException {
            Thread thread8 = new Thread(() -> {
                try {
                    synchronized (SIGN){
                        LOG.info("wait");
                        SIGN.wait();
                    }
                    LOG.info("wake up");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            thread8.start();
            Thread.sleep(3000);
            synchronized (SIGN){
                LOG.info("wake up thread ");
                SIGN.notify();
                Thread.sleep(2000);
            }
        }

日志输出:

2018-08-30 12:31:41.615 myAppName [Thread-0] INFO  com.river.other.ThreadInterruptedTest - wait
    2018-08-30 12:31:44.613 myAppName [main] INFO  com.river.other.ThreadInterruptedTest - wake up thread 
    2018-08-30 12:31:46.613 myAppName [Thread-0] INFO  com.river.other.ThreadInterruptedTest - wake up

## 2.1 场景分析 ##

线程Thread-0首先获得内置锁,调用wait()方法,使得当前线程处于 WAIT 状态,此时线程会释放锁;

主线程获得锁,调用监视对象的notify()方法唤醒Thread-0,主线程sleep 2s后释放锁,主线程结束运行;

此时Thread-0获得锁继续执行,打印go on ,执行完毕,结束运行;

## 2.2 知识点 ##

我们查看一下JDK中关于这几个方法的定义;

### 2.2.1 wait() , wait(long timeout), wait(long timeout, int nanos) ###

使当前线程等待(WAIT)直到另一个线程调用**此对象**的notify(),notifyAll()或者一段时间流逝之后;

当前线程必须拥有此对象的监视器;

该方法会使得当前线程(称之为T)将自己放置于对象的等待集中,然后放弃此对象上的所有同步要求;线程T对于线程调度变得不可用和休眠直到下面四件事情之一发生:

*  其他某个线程调用了此监视对象的notify(),并且线程T恰好被任意的选择唤醒;
 *  其他某个线程调用了此监视对象的notifyAll();
 *  其他某个线程调用此线程interrupt();
 *  指定的时间流逝;若指定时间为0,则只有当被调用notify(),notifyAll()才会被唤醒;

线程T被从此监视对象的等待集中移除时,对于线程调用重新变得可用,它接着会与其他在此监视对象上请求同步权利的线程以常规的方式竞争;一旦该线程获得了此对象的控制,所有在此对象上的同步要求都会被恢复,完全恢复到调用wait()方法时的样子;线程T将会从wait()方法的调用中返回;

一个线程也会在不notify(),interrupted或者时间流逝后唤醒,一个所谓的假的唤醒;虽然他很少的发生在实践中;应用必须在测试中警惕假唤醒的发生的情况,如果条件不满足继续处于wait状态;换句话说,wait应该始终发生在循环中,如下:

synchronized (obj) {
                  while (<condition does not hold>)
                      obj.wait(timeout);
                  ... // Perform action appropriate to condition
              }

解释一下上面的翻译:

监视对象就是锁对象,就是说在使用wait()一类方法和notify()一类方法时,必须先获得监视对象的锁,使用synchronized 关键字,synchronized 是一种JVM提供的内置锁,通常锁的对象有三种,详细点击[java 锁分析 synchronized 和 Lock][java _ synchronized _ Lock]2.2小结;若在没有获得监视对象锁的情况下调用,则会抛**java.lang.IllegalMonitorStateException**异常;

当调用wait()方法时,当前线程会被放置到监视对象的等待集中,同时不再持有锁,此时其他线程可以获得该监视对象的锁;线程进入WAIT状态,当被唤醒时,该线程将与其他等待相同监视对象锁的线程一样,等待CPU分配时间片,竞争锁,没有任何特权,该线程执行时,将完全恢复到调用wait()方法时的状态,继续执行接下来的方法;

个人理解当RUNNING线程中监视对象调用wait()使得现场变为WAIT状态,此时线程处于不可用,不可用是针对CPU分配时间片来讲的,jdk注释是这样讲的:

becomes disabled for thread scheduling purposes

也就是说不是线程调度对其无效,而是根本就是disabled,不在调度管理之中,CPU不会分配时间片给他;只有被唤醒才会被线程调度管理;

调用wait()方法处于WAIT的线程,会存在被假唤醒的情况,这种情况很罕见,但为了避免这种情况发生导致应用发生未知的异常,建议将wait()方法处于循环体中,如上面的例子,使线程在不满足被唤醒的条件时始终处于WAIT状态,避免被假唤醒;

针对上面被唤醒的四种场景,我们只重点介绍下第三种;其他三种都属于常规的唤醒WAIT中的线程,而第三种有一个异常 InterruptedException 需要处理;

package com.river.other;
    
    import lombok.extern.slf4j.Slf4j;
    import org.junit.Test;
    
    @Slf4j
    public class ObjectWaitTest {
    
        @Test
        public void test() throws InterruptedException {
            Thread thread1 = new Thread(() -> {
                synchronized (this) {
                    try {
                        log.info("wait...");
                        this.wait();
                        log.info("go on");
                    } catch (InterruptedException e) {
                        log.error("error");
                        e.printStackTrace();
                    }
                    log.info("go on...");
                }
            });
    
            thread1.start();
            Thread.sleep(2000);
    
            log.info("interrupt");
            Thread.sleep(500);
            thread1.interrupt();
        }
    }

日志输出:

2018-08-30 17:17:38.304 myAppName [Thread-0] INFO  com.river.other.ObjectWaitTest - wait...
    2018-08-30 17:17:40.300 myAppName [main] INFO  com.river.other.ObjectWaitTest - interrupt
    java.lang.InterruptedException
    	at java.lang.Object.wait(Native Method)
    	at java.lang.Object.wait(Object.java:502)
    	at com.river.other.ObjectWaitTest.lambda$test$0(ObjectWaitTest.java:15)
    	at java.lang.Thread.run(Thread.java:745)
    2018-08-30 17:17:40.800 myAppName [Thread-0] ERROR com.river.other.ObjectWaitTest - error
    2018-08-30 17:17:40.801 myAppName [Thread-0] INFO  com.river.other.ObjectWaitTest - go on...

通过日志分析可看到,处于WAIT状态的线程被调用interrupt()方法后,会立即抛出**InterruptedException**异常,该异常为检查异常,必须由编码处理的异常,catch异常之后线程会继续执行后面的操作;

突然想到了sleep();

@Test
        public void test() throws InterruptedException {
            Thread thread1 = new Thread(() -> {
                synchronized (this) {
                    try {
                        log.info("wait...");
                        //this.wait();
                        Thread.sleep(10000);
                        log.info("go on");
                    } catch (InterruptedException e) {
                        log.error("error");
                        e.printStackTrace();
                    }
                    log.info("go on...");
                }
            });
    
            thread1.start();
            Thread.sleep(2000);
            log.info("interrupt");
            Thread.sleep(500);
            thread1.interrupt();
        }

日志输出:

2018-08-30 17:27:28.955 myAppName [Thread-0] INFO  com.river.other.ObjectWaitTest - wait...
    2018-08-30 17:27:30.954 myAppName [main] INFO  com.river.other.ObjectWaitTest - interrupt
    
    2018-08-30 17:27:31.454 myAppName [Thread-0] ERROR com.river.other.ObjectWaitTest - error
    java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at com.river.other.ObjectWaitTest.lambda$test$0(ObjectWaitTest.java:16)
    	at java.lang.Thread.run(Thread.java:745)
    2018-08-30 17:27:31.454 myAppName [Thread-0] INFO  com.river.other.ObjectWaitTest - go on...

我们看到日志输出与上面无异;

那么这里使用wait()和sleep()有什么区别呢?

### 2.2.2 wait()和sleep() ###

wait() 用于必须获得监视对象锁之后执行,wait()方法调用后,会让出持有的锁供其他线程竞争获得;

通常用notify()唤醒,必须在获得同一监视对象锁在可以调用notify唤醒线程;

sleep() 使用没有限制,被调用后是当前线程让出CPU时间片,若在获得锁之后执行,则不会释放锁;

上面两者被interrupt打断后都会抛出**InterruptedException**异常需要处理;

### 2.2.3 notify() notifyAll() ###

notify用于唤醒当前监视对象等待集中WAIT的线程,若等待集中有多个线程,则调用notifyAll()将其全部唤醒,若此时调用notify(),则会唤醒任意一个线程(jdk中用词arbitrary),该方法不会释放持有的锁;

# 三. Thread sleep() interrupt() #

该处知识点已在上面有过对比介绍,不在重复了;

# 四. Condition await(),signal() #

请在另一篇文章[java 锁分析 synchronized 和 Lock][java _ synchronized _ Lock 1] 3.1.4小节中查看;

# 五. 小结 #

总的来讲,二和四主要是线程间通信的,使用原理基本一致,都需要在获得监视对象的锁的情况下才可以调用方法,为何如此呢?猜想既然是线程间通信,肯定是对同一资源或相关资源进行访问,线程之间彼此有影响,不然也不需要相互间保持通信,既然有影响,那么就需要同步,所以需要串行执行操作;

转载于:https://my.oschina.net/JackieRiver/blog/1936474

[2019_Python_]: https://my.oschina.net/u/2663968/blog/3061697
[hot3.png]: /images/20220113/7de15a6b78dd48fcbfb6a39a5bc66f66.png
[java _ synchronized _ Lock]: https://my.oschina.net/JackieRiver/blog/write/1649503
[java _ synchronized _ Lock 1]: https://my.oschina.net/JackieRiver/blog/1649503