sleep和wait区别

我们都知道修饰在普通方法和非静态方法上的synchronized形成的锁是对象锁。线程是交替执行抢占CPU时间片的，但是锁是一直存在的，如果不释放，线程是一直处在锁阻塞的状态。

Thread.sleep不会释放对象锁，一直持有，Object.wait会释放锁。

1550493118428.jpg

如图所示，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，但是结果并不是我们想的那样

image.png image.png

这两个结果都有出现，我猜测是因为子线程执行完，立即释放了锁(这需要时间)，而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线程会先执行完，再执行子线程，详细原因还要考究。