java线程泄露_java线程——notify通知的泄露

版权声明：本文为CSDN博主「兰亭风雨」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/ns_code/article/details/17228213

一,什么是Notify通知的泄露？

notify通知的遗漏很容易理解，即threadA还没开始wait的时候，threadB已经notify了，这样，threadB通知是没有任何响应的，当threadB退出synchronized代码块后，threadA再开始wait，便会一直阻塞等待，直到被别的线程打断。

二，实例

packagecom.itheima.gan;public classMessedNotify {//创建一个私有的变量,用来当锁

privateObject proceedLock;//创建一个构造方法,方法里面给私有变量赋值

publicMessedNotify() {

System.out.println(Thread.currentThread().getName()+" 进入MessedNotify()方法");

proceedLock=newObject();

}//方法1

public void waitToProceed() throwsInterruptedException {

System.out.println(Thread.currentThread().getName()+" 进入 waitToProceed()方法");synchronized(proceedLock) {

System.out.println(Thread.currentThread().getName()+" 进入 waitToProceed()方法后执行开始执行wait方法 ");//调用方法

proceedLock.wait();

System.out.println(Thread.currentThread().getName()+" 从in waitToProceed()-从wait方法返回");

}

System.out.println(Thread.currentThread().getName()+"in waitToProceed() -离开");

}//方法2

public voidproceed() {

System.out.println(Thread.currentThread().getName()+" in proceed()-enterd");synchronized(proceedLock) {

System.out.println(Thread.currentThread().getName()+" in proceed() -调用唤醒方法");//唤醒沉睡的线程

proceedLock.notifyAll();

System.out.println(Thread.currentThread().getName()+" in prooceed() -从唤醒方法处返回");

}

System.out.println(Thread.currentThread().getName()+" in proceed() -leaving");

}//主方法

public static voidmain(String[] args) {//创建一个对象

final MessedNotify mn =newMessedNotify();//创建两个线程,访问资源//创建一个线程A

Runnable runA=newRunnable() {

@Overridepublic voidrun() {//先休眠1000ms,大于runB中的500ms,为了使notify先执行

try{

Thread.sleep(1000);

mn.waitToProceed();

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}

};

Thread threadA=new Thread(runA,"threadA");//线程开始

threadA.start();//创建一个线程B

Runnable runB=newRunnable() {

@Overridepublic voidrun() {//先休眠500ms,大于runB中的500ms,为了使notify先执行

try{

Thread.sleep(500);

mn.proceed();

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}

};

Thread threadB=new Thread(runB,"threadB");//线程开始

threadB.start();try{

Thread.sleep(10000);

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}//试图打断wait阻塞

System.out.println(Thread.currentThread().getName()+"about to invoke interrupt() on threadA");

threadA.interrupt();

}

}

运行的结果：

分析：由于threadB在执行mn.proceed()之前只休眠了500ms，而threadA在执行mn.waitToProceed()之前休眠了1000ms，因此，threadB会先苏醒，继而执行mn.proceed()，获取到proceedLock的对象锁，继而执行其中的notifyAll()，当退出proceed()方法中的synchronized代码块时，threadA才有机会获取proceedLock的对象锁，继而执行其中的wait()方法，但此时notifyAll()方法已经执行完毕，threadA便漏掉了threadB的通知，便会阻塞下去。后面主线程休眠10秒后，尝试中断threadA线程，使其抛出InterruptedException。

三,解决notify通知泄露的问题？

为了修正MissedNotify，需要添加一个boolean指示变量，该变量只能在同步代码块内部访问和修改。修改后的代码如下：

packagecom.itheima.gan;public classMessedNotifyFix {//创建一个私有的变量,用来当锁

privateObject proceedLock;//创建一个标识位,用来判断线程是否需要等待

private boolean okToProceed;//创建一个构造方法,方法里面给私有变量赋值

publicMessedNotifyFix() {

System.out.println(Thread.currentThread().getName()+" 进入MessedNotifyFix()构造方法");

proceedLock=newObject();//初始化标识位

okToProceed=false;

}//方法1

public void waitToProceed() throwsInterruptedException {

System.out.println(Thread.currentThread().getName()+" 进入 waitToProceed()方法");synchronized(proceedLock) {

System.out.println(Thread.currentThread().getName()+"进入Lock资源");//while进行循环判断，不用if的原因是应为为了防止早期通知

while(okToProceed == false) {

System.out.println(Thread.currentThread().getName()+" 进入Lock资源后执行开始执行wait方法 ");//调用方法

proceedLock.wait();

System.out.println(Thread.currentThread().getName()+" 从wait方法返回");

}

System.out.println(Thread.currentThread().getName()+"离开Lock资源");

}

System.out.println(Thread.currentThread().getName()+" 线程从 waitToProceed()方法离开");

}//方法2

public voidproceed() {

System.out.println(Thread.currentThread().getName()+" 线程进入 proceed()方法");synchronized(proceedLock) {

System.out.println(Thread.currentThread().getName()+"进入proceedLock资源");//在唤醒沉睡的线程前先是标识位为true,这样就不会出现通知泄露的情况，也不会是线程在wait处阻塞，

//因为线程在标识位位false时才会进入wait方法。

okToProceed=true;

System.out.println(Thread.currentThread().getName()+" in proceed()调用唤醒方法");//唤醒沉睡的线程

proceedLock.notifyAll();

System.out.println(Thread.currentThread().getName()+" in prooceed()从唤醒方法处返回");

System.out.println(Thread.currentThread().getName()+"离开proceedLock资源");

}

System.out.println(Thread.currentThread().getName()+" 线程从 proceed()离开");

}//主方法

public static voidmain(String[] args) {//创建一个对象

final MessedNotifyFix mn =newMessedNotifyFix();//创建两个线程,访问资源//创建一个线程A

Runnable runA=newRunnable() {

@Overridepublic voidrun() {//先休眠1000ms,大于runB中的500ms,为了使notify先执行

try{

Thread.sleep(1000);

mn.waitToProceed();

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}

};

Thread threadA=new Thread(runA,"threadA");//线程开始

threadA.start();//创建一个线程B

Runnable runB=newRunnable() {

@Overridepublic voidrun() {//先休眠500ms,大于runB中的500ms,为了使notify先执行

try{

Thread.sleep(500);

mn.proceed();

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}

};

Thread threadB=new Thread(runB,"threadB");//线程开始

threadB.start();try{

Thread.sleep(10000);

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}//试图打断wait阻塞

System.out.println(Thread.currentThread().getName()+"about to invoke interrupt() on threadA");

threadA.interrupt();

}

}

运行结果：

注意：代码中加了注释的部分，在threadB进行通知(既调用notify方法之前)之前，先将okToProceed置为true，这样如果threadA将通知遗漏，那么就不会进入while循环，也便不会执行wait方法，线程也就不会阻塞。如果通知没有被遗漏，wait方法返回后，okToProceed已经被置为true，下次while循环判断条件不成立，便会退出循环。(先将标识位设置为false,那么如果线程B没有先执行,那么标识位依旧位false，线程A就会先执行，进入wait方法，然后线程B执行，将标识位设置为true,并且唤醒线程A，线程A退出wait()方法，继续执行while循环，while条件不成立，退出while)。

总结：在使用线程的等待/通知机制时，一般都要配合一个boolean变量值(或者其他能够判断真假的条件)，在notify之前改变该boolean变量的值，让wait返回后能够退出while循环(一般都要在wait方法外围加一层while循环，以防止早期通知)，或在通知被遗漏后，不会被阻塞在wait方法处。这样便保证了程序的正确性。