Java多线程-while死循环

示例代码如下所示：
线程A执行methodA()，methodA()中有一个死循环
线程B执行methodB()，当线程A进入methodA()中的死循环的时候，我们希望知道线程B能不能执行完成。

import java.util.*;
import java.util.concurrent.ThreadPoolExecutor;

public class test {

    public static void main(String[] args) {
        Service service=new Service();

        ThreadA threadA=new ThreadA(service);
        threadA.start();

        ThreadB threadB=new ThreadB(service);
        threadB.start();
    }

}

class Service{
    Object object1=new Object();

    public void methodA(){
        synchronized (object1){
            System.out.println("methodA begin");
            boolean isContinueRun=true;
            while(isContinueRun){

            }
            System.out.println("methodA end");
        }
    }

    Object object2=new Object();

    public void methodB(){
        synchronized (object2){
            System.out.println("methodB begin");
            System.out.println("methodB end");
        }
    }
}

class ThreadA extends Thread{

    private Service service;

    public ThreadA(Service service){
        super();
        this.service=service;
    }

    @Override
    public void run(){
        service.methodA();
    }
}

class ThreadB extends Thread{

    private Service service;

    public ThreadB(Service service){
        super();
        this.service=service;
    }

    @Override
    public void run(){
        service.methodB();
    }
}

执行结果如下：

由于线程A和线程B获得的对象锁不是同一把锁，从结果中可以看出，线程B是可以执行完成的。而线程A由于进入了while死循环，故线程A一直执行运行下去了（整个程序未结束），但线程B会结束。

也就是说，尽管线程A一直在while中执行，需要占用CPU。但是，线程的调度是由JVM或者说是操作系统来负责的，并不是说线程A一直在while循环，然后线程B就占用不到CPU了。对于线程A而言，它就相当于一个”计算密集型“作业。

如果将Service类改为如下的形式：

class Service{

    public void methodA(){
        synchronized (this){
            System.out.println("methodA begin");
            boolean isContinueRun=true;
            while(isContinueRun){

            }
            System.out.println("methodA end");
        }
    }

    public void methodB(){
        synchronized (this){
            System.out.println("methodB begin");
            System.out.println("methodB end");
        }
    }
}

这时的执行结果为：

如果线程A先获得对象锁时，由于while循环，线程A一直在while循环中。而线程B也因为无法获得锁而执行不了methodB()。

可以看出，如果一个线程在synchronized方法中无法退出，无法将锁释放，另一个线程就只能无限等待了。