wait主要用於切換線程，sleep主要用來阻塞當前線程
Java多線程一篇不錯的文章推薦下Java多線程
(1)、常用的wait方法有wait()和wait(long timeout);
void wait() 在其他線程調用此對象的 notify() 方法或者 notifyAll()方法前，導致當前線程等待。
void wait(long timeout)在其他線程調用此對象的notify() 方法 或者 notifyAll()方法，或者超過指定的時間量前，導致當前線程等待。
wait()後，線程會釋放掉它所佔有的“鎖標誌”，從而使線程所在對象中的其他synchronized數據可被別的線程使用。
wait()和notify()因爲會對對象的“鎖標誌”進行操作，所以他們必需在Synchronized函數或者 synchronized block 中進行調用。如果在non-synchronized 函數或 non-synchronized block 中進行調用，雖然能編譯通過，但在運行時會發生IllegalMonitorStateException的異常。。
(2)、Thread.sleep(long millis)必須帶有一個時間參數
sleep(long)使當前線程進入停滯狀態，所以執行sleep()的線程在指定的時間內肯定不會被執行；
sleep(long)可使優先級低的線程得到執行的機會，當然也可以讓同優先級的線程有執行的機會；
sleep(long)是不會釋放鎖標誌的。
public class MultiThreadClient {
private Consumer consumer;
private Producer producer;
private List<Object> mProducts = new ArrayList<>();
public List<Object> getmProducts() {
return this.mProducts;
}
public void stopThread() {
consumer.setExit(true);
producer.setExit(true);
}
public void startThread() {
MultiThreadClient client = new MultiThreadClient();
//啓動多個線程
consumer = new Consumer(client.getmProducts());
producer = new Producer(client.getmProducts());
Thread consumerThread = new Thread(consumer);
Thread producerThread = new Thread(producer);
consumerThread.start();
producerThread.start();
}
}
public class Consumer implements Runnable {
public volatile boolean exit = false;
private List<Object> mProducts;
private int mCount = 0;
public Consumer(List<Object> products) {
this.mProducts = products;
}
public void setExit(boolean exit) {
this.exit = exit;
}
@Override
public void run() {
while (!exit) {
synchronized (mProducts) {
while (mProducts.size() == 0) {
try {
System.out.println("庫存清倉，等待生產者生產，消費者進行等待");
mProducts.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
mProducts.remove(0);
mProducts.notify();
System.out.println("我是消費者，已經消費掉了" + (++mCount) + "個產品" + " 庫存數量" + mProducts.size());
}
}
}
}
public class Producer implements Runnable {
public volatile boolean exit = false;
private List<Object> mProducts;
private int mCount = 0;
private static final int mMaxCount = 5;
public Producer(List<Object> products) {
this.mProducts = products;
}
public void setExit(boolean exit) {
this.exit = exit;
}
@Override
public void run() {
while (!exit) {
synchronized (mProducts) {
while (mProducts.size() > mMaxCount) {
try {
System.out.println("庫存已滿，等待消費者消費，生產者等待");
mProducts.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
mProducts.add(new Object());
mProducts.notify();
System.out.println("我是生產者，我已經生產了" + (++mCount) + "個產品" + " 庫存數量" + mProducts.size());
}
}
}
}
輸出結果：
I/System.out: 庫存清倉，等待生產者生產，消費者進行等待
I/System.out: 我是生產者，我已經生產了1個產品 庫存數量1
I/System.out: 我是生產者，我已經生產了2個產品 庫存數量2
I/System.out: 我是生產者，我已經生產了3個產品 庫存數量3
I/System.out: 我是生產者，我已經生產了4個產品 庫存數量4
I/System.out: 我是生產者，我已經生產了5個產品 庫存數量5
I/System.out: 我是生產者，我已經生產了6個產品 庫存數量6
I/System.out: 庫存已滿，等待消費者消費，生產者等待
I/System.out: 我是消費者，已經消費掉了1個產品 庫存數量5
I/System.out: 我是消費者，已經消費掉了2個產品 庫存數量4
I/System.out: 我是消費者，已經消費掉了3個產品 庫存數量3
I/System.out: 我是消費者，已經消費掉了4個產品 庫存數量2
I/System.out: 我是消費者，已經消費掉了5個產品 庫存數量1
I/System.out: 我是消費者，已經消費掉了6個產品 庫存數量0
I/System.out: 庫存清倉，等待生產者生產，消費者進行等待
I/System.out: 我是生產者，我已經生產了7個產品 庫存數量1
I/System.out: 我是生產者，我已經生產了8個產品 庫存數量2
I/System.out: 我是生產者，我已經生產了9個產品 庫存數量3
I/System.out: 我是生產者，我已經生產了10個產品 庫存數量4
I/System.out: 我是生產者，我已經生產了11個產品 庫存數量5
I/System.out: 我是消費者，已經消費掉了7個產品 庫存數量4