条件拥塞队列原理学习
package com.thread.test6;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @fileName 条件阻塞队列原理
* @description 条件阻塞队列原理学习
* @date 2012-6-17
* @time 21:01
* @author wst
*
*/
public class BlockingQueue {
public static void main(String[] args) {
final BlockingQueue bq=new BlockingQueue();
for(int i=1;i<=50;i++){
final int data=i;
new Thread(new Runnable(){
@Override
public void run() {
try {
System.out.println("线程"+data+"存入的数据："+"data"+data);
bq.put("data"+data);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
for(int i=1;i<=50;i++){
final int data=i;
new Thread(new Runnable(){
@Override
public void run() {
try {
System.out.println("线程"+data+"取出的数据："+bq.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
final Lock lock=new ReentrantLock();
final Condition notFull=lock.newCondition();
final Condition notEmpty=lock.newCondition();
final Object[] items=new Object[100];
int putptr,takeptr,count;
/**
* 向队列存放数据，从第一个开始存，直到存完
* @param obj
* @throws InterruptedException
*/
public void put(Object obj) throws InterruptedException{
lock.lock();
try{
while(count==items.length){//存放数据已满
notFull.await();//等待
}
items[putptr]=obj;//给存入的对象分配位置
if(++putptr==items.length){//存放的数据到最后一个位置了，则下次从第一个位置开始存放
putptr=0;
}
++count;//存放数量增加
notEmpty.signal();//通知取数据方法，可以取数据了
}finally{
lock.unlock();
}
}
/**
* 取数据，从第一个开始取，直到取完
* @return 一个对象
* @throws InterruptedException
*/
public Object take() throws InterruptedException{
lock.lock();
try{
while(count==0){
notEmpty.await();//没有数据了，则等待
}
Object obj=items[takeptr];
if(++takeptr==items.length){
takeptr=0;
}
--count;
notFull.signal();//每取走一个数据就告诉存数据方法，可以存放数据了
return obj;
}finally{
lock.unlock();
}
}
}