MyException - 我的异常网
当前位置:我的异常网» J2SE » java线程interrupte()方法中 重新获取锁 疑问求解!

java线程interrupte()方法中 重新获取锁 疑问求解!解决办法

www.MyException.Cn  网友分享于:2013-12-29  浏览:26次
java线程interrupte()方法中 重新获取锁 疑问求解!
最近看到java多线程,《java多线程设计模式详解》书中提到:“线程在进入等待区时,会把锁定解除。当对wait中的线程(即等待被取消的线程)调用interrupt()方法时,会先重新获取锁定,在抛出InterruptedException异常,在获取锁定之前,并无法抛出InterruptedException异常”。

  我的理解是:如果无法获取锁定,则即使调用interrupte方法也不会抛出异常,现在我疑问的是这个锁是什么锁??
好像不是调用wait()的锁,因为我写了3个类做了简单的测试,发现不获取锁定一样能够抛出异常

  希望各位多线程高手能指点指点

A类:
public class A extends Thread{
private final Object o = new Object();
private static boolean test = true;
public A(String name)
{
super(name);
}
public void run()
{

System.out.println(Thread.currentThread().getName()+"开始运行");
int i = 0;
synchronized(o) {
try {
  //死循环
while(true){
if(test)  
  //test为静态变量,改变后其他实例线程就不会进入wait()状态
  //保证第二个线程不会进入wait状态,第二个线程在死循环中一直占有锁
{
test = false;
System.out.println(Thread.currentThread().getName()+"开始进入等待");
o.wait();


}
System.out.println(Thread.currentThread().getName()+"正在运行,次数:"+i);

Thread.sleep(1000);
i++;
}
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName()+"退出");
}

}
}
}


B类:
public class B extends Thread{
private Thread t ;
public B(Thread t)
{
this.t = t;
}
public void run(){
try {
System.out.println("线程B开始运行");
Thread.sleep(6000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("开始取消线程");
t.interrupt();//调用一个线程的中断方法
System.out.println("线程取消方法被调用,B退出");
}
}

测试主类:
public class TestMain {
public static void main(String[] args) {
A a1 = new A("a1");
A a2 = new A("a2");
B b = new B(a1);
a1.start();
a2.start();//a1会进入wait()方法,a2则一直运行
b.start();
}
}



在线程b中调用a1线程的中断interrupt方法后,a1线程抛出异常被捕获,然后a1线程退出


------解决方案--------------------
如果书上真是那么描述的,只能说明作者根本不懂。

“线程在进入等待区时,会把锁定解除。当对wait中的线程(即等待被取消的线程)调用interrupt()方法时,会先重新获取锁定,在抛出InterruptedException异常,在获取锁定之前,并无法抛出InterruptedException异常”
正确的描述是:
“线程在进入等待区时,会把锁定解除。当对wait中的线程(即等待被取消的线程)调用interrupt()方法后,如果线程重新获取了锁定,会抛出InterruptedException异常,在获取锁定之前,并无法抛出InterruptedException异常”

如果线程a进入wait,它释放了锁,这时其它线程(不一定是获取了锁的那个线程,有可能就不和他们产生锁竞争的线程)调用了a的interrupt()方法,没有任何反映,只是改变了a的可执行状态,如果没有调用,当a有机会获取到锁时,就会检查是否达到wait的时间,如果没有达到就继续wait,达到了就恢复执行,而如果a被调用了interrupt()方法的瞬间,因为只是状态被修改为已经被中断(isInterrupted),如果它有机会获取到锁,才会抛出异常。而如果其它线程一直抓住锁没有释放,那么它当然不会抛出异常(没有难给它发言的机会啊,只是它的内部状态被标记为isInterrupted而已)。
------解决方案--------------------
现在我疑问的是这个锁是什么锁??
---
就是指你调用.wait那个对象锁,即
synchronized(o)这个

你把代码这样写

Java code

        final Object o = new Object();
        Thread t = 
        new Thread() {
            public void run() {
                synchronized (o) {
                    try {
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("After Wait");
                }
            }
        };
        t.start();
        Thread.sleep(2000);
        synchronized (o) {
            t.interrupt();
            System.out.println("After Interrupt");
            Thread.sleep(5000);
            System.out.println("After Sleep");
        }

------解决方案--------------------
a1线程有有机会获得锁定,但是没有通过o.notify()通知,如果别的线程调用t.interrupt(),会促使a线程去重新获得锁定,这是就会抛出异常,书上说的没错,只是比较模糊而已。
------解决方案--------------------
a1线程跟a2线程在对象锁方面没有关系。对象o,两个线程互相隔离。

文章评论

软件开发程序错误异常ExceptionCopyright © 2009-2015 MyException 版权所有