多线程(初阶五:wait和notify)

目录

一、概念

二、用法

(1)举个栗子:

(2)wait和notify的使用

1、没有上锁的wait

2、当一个线程被wait,但没有其他线程notify来释放这个wait

3、两个线程,有一个线程wait,有一个线程notify来释放wait

4、notifyAll

(3)wait的三个选项

三、wait、sleep、join


一、概念

我们知道,多线程在系统中的调度是随机的,我们不能干预多个线程的执行顺序,但是我们可以使某个线程放弃被系统调用,让其他线程先被调用,这样,可以达到我们的预期效果;

wait就是让多线程进行锁竞争的时候,让后执行的线程,放弃和别的线程进行锁竞争,别的线程执行完后,别的线程使用notify,将wait的线程不想进行锁竞争这个信息释放掉,再次和其他线程锁竞争。等待,通知的机制(和join用途类似)


二、用法

(1)举个栗子:

现在有很多滑稽老铁要去ATM里,滑稽A是取钱的,滑稽B是存钱的,滑稽C是运钞票的人员,负责给ATM机补充钱,防止ATM机没钱了,别人取不到钱。而这里的滑稽A,滑稽B,滑稽C我们当做是线程,每次去ATM机里,只能有一个人进去,相当于上锁了,其他人不能进去,等ATM机里面的人完成操作后,出来后,别的人才能进去,但是这里是多线程的原因,其他线程会有锁竞争。     

当A进去ATM机里后,就上锁,其他人不能进去,如图:

多线程(初阶五:wait和notify)_第1张图片

把滑稽A比作是线程,当A线程进去后就会上锁,A线程要进行取钱的操作,其他线程不能进去操作,当A线程执行完自己的操作后,其他线程才能去锁竞争。

但是如果ATM机里面没有钱时,A线程就不能完成取钱这个操作,它会退出ATM机,但退出后呢,它因为没有完成取钱的操作,就会想继续进去ATM里面,完成取钱这个操作,就会继续和其他线程进行锁竞争,因为A线程拿到了锁,处于RUNNABLE状态,其他线程因为阻塞,处于BLOCKED状态,需要被系统唤醒后,才能去竞争锁,但是线程A呢,不用唤醒就能去竞争锁,后面又被A线程拿到锁的可能性还是很大的(类似近水楼台先得月)。如果这样子,那线程A频繁的进去又出来,干不了事,但是其他线程也不能进去操作,用通俗的话说,就是占着茅坑不拉屎的意思。也就出现线程安全问题了。其他线程,无法拿到锁,这个情况称为 “线程饿死”。

这里的线程A的代码大概逻辑是这样的:

多线程(初阶五:wait和notify)_第2张图片

当A线程没有取到钱,就会一直重复加锁,解锁的操作。

这样的bug没有死锁那么严重,但也是要解决的。那如何解决呢。这时,就可以用wait和notify了。期望改进成,如下图:

多线程(初阶五:wait和notify)_第3张图片

这里的wait内部做了三件事

(1)释放锁,给其他线程竞争锁

(2)进入阻塞等待

(3)等其他线程使用notify后,解除wait,参与到锁竞争中

(2)wait和notify的使用

wait的使用前提必须是当前对象被上锁了才能使用,不能你对象没被上锁,就wait了,那也不知道是在wait谁。同时,有线程wait了,也必须有其他线程notify来释放这个wait,不然这个wait就会一直阻塞。

1、没有上锁的wait

代码:

public class TestDemo1 {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        locker.wait();
    }
}

执行结果:

多线程(初阶五:wait和notify)_第4张图片

2、当一个线程被wait,但没有其他线程notify来释放这个wait

代码:

public class TestDemo3 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("wait之前");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("wait之后");
            }
        });
        t1.start();
    }
}

执行结果:

多线程(初阶五:wait和notify)_第5张图片

打印不了 “wait之后”,一直是阻塞等待状态,在jconsole中,状态如图

多线程(初阶五:wait和notify)_第6张图片

3、两个线程,有一个线程wait,有一个线程notify来释放wait

代码:

public class TestDemo2 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("t1 wait之前");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("t2 wait之后");
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (locker) {
                System.out.println("t2 notify之前");
                locker.notify();
                System.out.println("t2 notify之后");
            }
        });
        t1.start();
        t2.start();
    }
}

注意:这里的释放wait的notify,用的对象必须是要一样的,如果不一样,wait是不能被释放的,t1也就不能被唤醒了.

在系统中,notify可以不用上锁,但是在java中,规定了要上锁,而且上锁的对象也要和notify对象一样,所以和系统是有区别的。

执行结果:

多线程(初阶五:wait和notify)_第7张图片

结果解析:

t1 和 t2 执行的时候

(1)因为t1 sleep了1秒,所以能保证t1 先wait,所以先打印 “t1 wait之前”,这时,t1就进入阻塞等待状态。

(2)t2线程sleep了1秒后,获得这个locker锁,打印“t2 notify 之前”,当t2线程执行了notify后,t1 线程的wait就被释放了。

(3)因为t2还在持有锁,所以t1会还会进入阻塞,t2打印 “t2 notify之后” ,释放锁。

(4)t1拿到锁,再打印“t1 wait之后”。

4、notifyAll

唤醒等待这个对象的所有线程;假设有很多个线程,都使用同一个对象wait,这时,使用notifyAll,所有使用了这个对象的wait的线程,都会被唤醒。

注意:当这些线程都被唤醒时,就要重新获取锁,他们还是要进行锁竞争的,这里也就相当于串行执行了(线程调度还是随机调度的)。而且使用notifyAll后,全部使用同一对象wait的线程,都被唤醒了,不好控制,更加推荐使用notify。

(3)wait的三个选项

如图:

多线程(初阶五:wait和notify)_第8张图片

没有参数的就是死等,但是很多情况,死等是不合理的,所以我们加参数,就是让某个线程在一定时间wait,如果超出了这个时间,就不wait了,直接过掉wait。

有一个参数的精确范围是毫秒级别,两个参数的精确范围是纳秒级别。


三、wait、sleep、join

wait:需要搭配synchronized使用,线程wait时,处于WAITING状态,需要其他线程notify后,才能被唤醒,或者设置时间,到时就唤醒,可以兜底。

sleep:线程sleep时,要到一定休眠时间才能被唤醒,但是也能被interrupt终止,但是这种情况是会抛异常的,是非常规手段,不符合我们预期的效果。

join:啥线程调用join,当前线程就要等啥线程执行完,才能之前当前线程;和wait一样有参数可以选择,到时就不等了。

你可能感兴趣的:(java,开发语言,java-ee)