分析:
1.在庫存爲滿時,生產者纔可以生產,同理有庫存時消費者纔可以消費,否則就等待。
2.當消費者消費完,活着生產者生產完 應該去通知對方,並釋放對象鎖
3.對象的wait方法,wait方法的作用是釋放當前線程的所獲得的鎖,
4.notifyAll() 方法, 通知(喚醒)該對象上其他等待線程,使得其繼續執行。
5.synchronized關鍵字只作用與當前實例對象的方法。
package com.producer.consumer;
public class MainTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
/**
* 初始化數據池和一個生產線程A 兩個消費線程D E
*
*/
BufferData data = new BufferData();
new Thread(new Producer(data, "A")).start();
// new Thread(new Producer(data,"B")).start();
// new Thread(new Producer(data,"C")).start();
new Thread(new Consumer(data, "D")).start();
new Thread(new Consumer(data, "E")).start();
}
}
生產者
package com.producer.consumer;
public class Producer implements Runnable {
public String mThreadName;
public BufferData mData;
public Producer(BufferData data, String threadName) {
this.mThreadName = threadName;
this.mData = data;
}
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//隨機生產存入 數據池
int random = (int) (Math.random() * 1000 + 1);
mData.toProducer(random);
System.out.println(mThreadName + "線程存入:" + random);
}
}
}
消費者
package com.producer.consumer;
public class Consumer implements Runnable {
public String mThreadName;
public BufferData mBufferData;
public Consumer(BufferData data, String threadName) {
this.mBufferData = data;
this.mThreadName = threadName;
}
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
int value = mBufferData.toConsumer();
System.out.println(mThreadName + "線程消費:" + value);
}
}
}
線程基礎知識點
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 線程池配置參數說明
* 第一個參數核心線程數 併發的
* 第二個參數 非核心線程數=核心線程數+緩存隊列Runnable數
* 第三個參數 非核心線程超時時間
* 第四個參數 時間單位
* 第五個參數緩存隊列
* ArrayBlockingQueue 大小固定的 順序執行
* LinkedBlockingQueue 無限制的 順序執行
* PriorityBlockingQueue 優先級執行
* SynchronizedQueue 同步執行 併發 不緩存
* 第六個線程工廠
* @author zwh
*
*/
public class LocalThreadPool {
private static LocalThreadPool mInstance;
private ThreadPoolExecutor threadPool;
private static int MAX_CORE_NUMBER = Runtime.getRuntime().availableProcessors();
private LocalThreadPool() {
threadPool = new ThreadPoolExecutor(MAX_CORE_NUMBER, 10, 60, TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(), new ThreadFactory() {
AtomicInteger auto = new AtomicInteger(0);
@Override
public Thread newThread(Runnable r) {
// TODO Auto-generated method stub
Thread thread = new Thread(r, "crate-thread-" + auto.incrementAndGet());
System.out.println("create thread:" + thread.getName());
return thread;
}
});
threadPool.allowCoreThreadTimeOut(true);
}
public static LocalThreadPool getInstance() {
if (mInstance == null) {
synchronized (LocalThreadPool.class) {
if (mInstance == null) {
mInstance = new LocalThreadPool();
}
}
}
return mInstance;
}
public Future<?> submit(Runnable runnable) {
return threadPool.submit(runnable);
}
public int count() {
return threadPool.getActiveCount();
}
public void destory() {
threadPool.shutdown();
}
}