我们都知道修饰在普通方法和非静态方法上的synchronized形成的锁是对象锁。线程是交替执行抢占CPU时间片的，但是锁是一直存在的，如果不释放，线程是一直处在锁阻塞的状态。
Thread.sleep不会释放对象锁，一直持有，Object.wait会释放锁。
如图所示，sleep的对象仍旧在Waiting Queue中，并不进入阻塞队列的等待池，而是在锁池徘徊，monitor锁仍旧持有，保持监控状态。直到同步代码块的代码执行完毕，释放锁。之前被monitor阻塞的线程才能重新获取monitor锁。而wait()的对象会释放锁，进入Waiting Queue
下面我们来看这段代码:
package TestDemo;
public class ThreadTest implements Runnable {
int number = 10;
public void firstMethod() throws Exception {
synchronized (this) {
number += 100;
System.out.println(number);
}
}
public void secondMethod() throws Exception {
synchronized (this) {
/**
* (休息2S,阻塞线程)
* 以验证当前线程对象的机锁被占用时,
* 是否被可以访问其他同步代码块
*/
Thread.sleep(2000);
//this.wait(2000);
number *= 200;
}
}
@Override
public void run() {
try {
firstMethod();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception {
ThreadTest threadTest = new ThreadTest();
Thread thread = new Thread(threadTest);
thread.start();
threadTest.secondMethod();
}
}
我们来分析一下代码，main线程始终执行，main方法中实例化了ThreadTest，启动了一个子线程，但是由于main方法先调用了实例的普通方法，实例的普通方法(secondMethod)先执行，因为启动一个线程是耗时操作，然后second方法中，sleep方法并不退出锁池，一直会执行完secondMethod才释放，在这之前子线程处于锁阻塞状态，此时时间片被子线程抢占，子线程执行firstMethod，因而结果是10*200+100=2100
当我们把sleep换成wait时，main线程执行secondMethod，由于wait会释放锁，进入waiting Set等待池，所以子线程抢占时间片，此时monitor锁可以被抢占，子线程不必进入锁阻塞状态，因而firstMethod被执行，打印出了110。
如果我们在主线程中加一句打印:
public class ThreadTest implements Runnable {
int number = 10;
public void firstMethod() throws Exception {
synchronized (this) {
number += 100;
System.out.println(number);
}
}
public void secondMethod() throws Exception {
synchronized (this) {
/**
* (休息2S,阻塞线程)
* 以验证当前线程对象的机锁被占用时,
* 是否被可以访问其他同步代码块
*/
Thread.sleep(2000);
//this.wait(2000);
number *= 200;
}
}
@Override
public void run() {
try {
firstMethod();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception {
ThreadTest threadTest = new ThreadTest();
Thread thread = new Thread(threadTest);
thread.start();
threadTest.secondMethod();
System.out.println("number=:"+threadTest.number);
}
}
结果也很好分析
main线程中实例调用普通方法，快于子线程，main线程执行同步方法，子线程处于锁阻塞，执行同步代码块，number=2000，main线程执行完同步块，释放锁，子线程获取锁，number=2100，输出2100，释放锁，main线程继续执行，输出2100，但是结果并不是我们想的那样
这两个结果都有出现，我猜测是因为子线程执行完，立即释放了锁(这需要时间)，而main线程继续执行则很快，因而会出现图1的情形，要想使结果明朗，我们只需要将sleep方法加入到打印的后面，确保打印完成即可确保出现图二
public void firstMethod() throws Exception {
synchronized (this) {
number += 100;
System.out.println(number);
Thread.sleep(2000);
}
}
此外，上述过程中，main线程释放锁，子线程是立刻获取锁的，有没有可能，让子线程等待，然后main线程继续执行呢，答案是有可能的，只需要在
public void firstMethod() throws Exception {
synchronized (this) {
Thread.sleep(2000);
number += 100;
System.out.println(number);
}
}
第一行让线程等待即可，main线程会先执行完，再执行子线程，详细原因还要考究。
