■基础

进程：Process

线程：Thread

【相同点】

都会让线程进入阻塞（Blocked）状态

【不同的】

1.每一个Object对象，都有一个锁，【wait】会释放锁，【sleep】不会释放锁。（即，不会释放同步监视器）

详细解释
1.Monitor是一种用来实现同步的工具 （锁：【同步监视器】）
2.与每个java对象相关联，即每个java对象都有一个Monitor与之对应
3.Monitor是实现Sychronized(内置锁)的基础

??2.【wait】与【notify】是Object的方法。【sleep】是Thread的方法

?3.【wait】与【notify】只能用于【synchronized】同步块中

? ? ? ? ? ? 【sleep】只要是在run方法中，就可以使用。

?4.【wait】释放锁，解除对当前操作对象的占用，

5.关于阻塞后的唤醒：【sleep】自动唤醒。被【wait】的，需要其他【synchronized】同步块中，使用【notify】或【notifyAll】方法来唤醒。

6.唤醒与锁的释放

调用notify()并不立即释放锁。它只是告诉某个正在等待的线程可以被唤醒，当同步快的所有代码执行完之后，锁才会被真正释放。

7.? ?用法（套路）
　　一般的用法【等待-通知机制】，套路如下：
　　1、Thread1中判断某一条件不成立while(!【condition】)，然后调用wait()方法。
　　2、Thread2中建立该条件如【condition】=true，然后调用notify()。
? ? ? ?※【condition】是同一对象中的变量。（即， Thread1，2同时操作同一对象）

■代码示例1（生产者与消费者）

0.ProductTest.java

package com.sxz.study.thread;
 
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk(); 
 
        // 生产者线程
        Thread producerThread = 
            new Thread(
                new Producer(clerk)); 
        // 消费者线程
        Thread consumerThread = 
            new Thread(
                new Consumer(clerk)); 
 
        producerThread.start(); 
        consumerThread.start(); 
    }
}

1.Clerk.java

package com.sxz.study.thread;
 
public class Clerk {
    // -1 表示目前没有产品
    private int product = -1; 
 
     // 这个方法由生产者调用
    public synchronized void setProduct(int product) { 
        if(this.product != -1) { 
            try { 
              // 目前店员没有空间收产品，请稍候！
                wait(); 
            } 
            catch(InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
 
        this.product = product; 
        System.out.printf("生产者设定 (%d)%n", this.product); 

      // 通知等待区中的一个消费者可以继续工作了
        notify(); 
    } 
    
    // 这个方法由消费者调用
    public synchronized int getProduct() { 
        if(this.product == -1) { 
            try { 
                  // 缺货了，请稍候！
                wait(); 
            } 
            catch(InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
 
        int p = this.product; 
        System.out.printf("消費者取走 (%d)%n", this.product); 
        this.product = -1; // 取走产品，-1表示目前店员手上无产品
 
         // 通知等待区中的一个生产者可以继续工作了
        notify(); 
       
        return p; 
    } 
}

2.Consumer.java

package com.sxz.study.thread;
 
public class Consumer implements Runnable {
    private Clerk clerk; 
    
    public Consumer(Clerk clerk) { 
        this.clerk = clerk; 
    } 
    
    public void run() { 
        System.out.println(
                "消费者开始消耗整数......"); 

        // 消耗10个整数
        for(int i = 1; i <= 10; i++) { 
            try { 
                 // 等待随机时间
                Thread.sleep((int) (Math.random() * 3000)); 
            } 
            catch(InterruptedException e) { 
                e.printStackTrace(); 
            } 

              // 从店员处取走整数
            clerk.getProduct(); 
        } 
    } 
 }

3.Producer.java

package com.sxz.study.thread;
 
public class Producer implements Runnable {
    private Clerk clerk; 
    
    public Producer(Clerk clerk) { 
        this.clerk = clerk; 
    } 
    
    public void run() { 
        System.out.println(
                "生产者开始生产整数......"); 

        // 生产1到10的整数
        for(int product = 1; product <= 10; product++) { 
            try { 
                // 暂停随机时间
                Thread.sleep((int) Math.random() * 3000); 
            } 
            catch(InterruptedException e) { 
                e.printStackTrace(); 
            } 
            // 将产品交给店员
            clerk.setProduct(product); 
        }       
    } 
}

---

运行结果

消费者开始消耗整数......
生产者开始生产整数......
生产者设定 (1)
消費者取走 (1)
生产者设定 (2)
消費者取走 (2)
生产者设定 (3)
消費者取走 (3)
生产者设定 (4)
消費者取走 (4)
生产者设定 (5)
消費者取走 (5)
生产者设定 (6)
消費者取走 (6)
生产者设定 (7)
消費者取走 (7)
生产者设定 (8)
消費者取走 (8)
生产者设定 (9)
消費者取走 (9)
生产者设定 (10)
消費者取走 (10)

---

■其他：代码示例2：（sleep，join）

public class ThreadA {
    public static void main(String[] args) {
        System.out.println("Thread A执行");

        Thread threadB = new Thread(new Runnable() { 
            public void run() { 
                try { 
                    System.out.println("Thread B开始.."); 
                    for(int i = 0; i < 5; i++) { 
                        Thread.sleep(1000); 
                        System.out.println("Thread B 执行.."); 
                    }
                    System.out.println("Thread B  即将结束.."); 
                } 
                catch(InterruptedException e) { 
                    e.printStackTrace(); 
                } 
            } 
        });
        
        threadB.start();

        try {
             // Thread B 加入 Thread A
            threadB.join();
        } 
        catch(InterruptedException e) { 
            e.printStackTrace(); 
        } 

        System.out.println("Thread A 执行");
    }
}

---