多线程(八)

一、wait和notify

等待通知机制

和join的用途类似,多个线程之间随机调度,引入 wait notify 就是为了能够从应用层面上,干预到多个不同线程代码的执行顺序.( 这里说的干预,不是影响系统的线程调度策略内核里的线程调度,仍然是无序的.

相当于是在应用程序代码中,让后执行的线程,主动放弃被调度的机会,就可以让先执行的线程,先把对应的代码执行完了.

当有一堆线程要去对同一个对象上锁时,就需要竞争.然后会有一个线程最先拿到这个锁,那么,其他线程就要等待这个线程解锁.但是,有可能会发生,条件不足,导致这个线程要执行的任务没有执行完成,就解锁了.

此时,其他的线程都会参与到锁这个竞争中.

但是,因为第一个进去的并没有完成任务,所以第一个线程也会参与到锁竞争中.

此时,就完全有可能,这个第一个线程他又拿到了锁.

这就会导致一种情况 : 这个线程一直在加锁解锁,但是任务始终没有做完,而其他线程又没法进入这个锁执行任务.

这个情况,称为 " 线程饿死 " .也可以叫做 " 线程饥饿 ".

这种问题属于概率性事件,不想死锁那样,一旦出现了,程序就出问题了.

但是这会极大的影响到其他线程的进行.也就是一种bug.

这个问题的关键在于,第一个线程,发现进行这个操作,无法让自己完成任务,就需要令其阻塞,先让其他线程去竞争这个锁,等到条件可以让第一个线程完成任务了,再借出这个线程的阻塞.

此时,就需要用到wait和notify.

可以使用wait先令其阻塞,等其他线程让条件满足后,再使用notify唤醒.

wait的内部做了三件事 :

1. 释放锁

2. 进入阻塞等待

3. 当其他线程调用notify时,wait解除阻塞,并重新获取到锁.

join和wait的区别 :

join是等待另一个线程结束,才能执行.

wait是等待另一个线程通过notify唤醒才能执行.

阻塞产生的原因 :

1. sleep TIMED_WAITING

2. join WAITING

3. synchronized BLOCKED

wait必须要放到synchronized里面使用,因为wait第一步是释放锁,所以首先要就行加锁.

wait和 sleep join 是一类,都有可能被interrupt提前唤醒.

notify其实可以不用放到synchornizec里的,不需要先加锁的. ( 但再java中特别约定,要把notify放到synchronized里 )

ps : 操作系统原生api也有wait 和 notify,原生的wait需要先加锁,notify不需要先加锁.

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

        Thread t2 = new Thread(()->{
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (A){
                System.out.println("nofity之前");
                A.notify();
                System.out.println("notify之后");
            }
        });

        t1.start();
        t2.start();
    }

以上代码运行后,我们就可以发现,再打印" wait之前 "之后,停顿了一会儿才继续打印.