多线程练习之有界的缓存

package cn.sp.test;

import java.util.concurrent.Semaphore;

/**
 * 有界的缓存
 * @author pc
 *
 * @param <E>
 */
public class BoundedBuffer<E> {
    private final Semaphore availableItems;//可用项   信号量 
    private final Semaphore availableSpaces;//可用空间  信号量 
    private final E[] items;
    private  int putPosition = 0,takePosition = 0;
    
    @SuppressWarnings("unchecked")
    public BoundedBuffer(int capacity){
        availableItems = new Semaphore(0);
        availableSpaces = new Semaphore(capacity);
        items = (E[]) new Object[capacity];
    }
    
    public boolean isEmpty(){//可用许可为0
        return availableItems.availablePermits() == 0;
    }
    
    public  boolean isFull(){//满时可用空间为0
        return availableSpaces.availablePermits() == 0 ;
    }
    
    public void put(E x) throws InterruptedException{
        availableSpaces.acquire();
        doInsert(x);
        availableItems.release();
    }
    
    public E take() throws InterruptedException{
        availableItems.acquire();//从 availableItems 获取 一个许可
        E e = doExtract();
        availableSpaces.release();//返回  一个许可 到 availableSpaces
        return e;
    }

    private synchronized E doExtract() {
        int i = takePosition;
        E x = items[i];
        //取出后 调用垃圾收集器
        items[i] = null;
        takePosition = (++i == items.length)? 0 : i;
        return x;
    }

    private  synchronized void doInsert(E x) {//同步方法
        int i = putPosition;
        items[i] = x;
        //如果满了重置为0
        putPosition = (++i == items.length) ? 0 :i;
        
    }
}

测试类：

package cn.sp.test;

import org.junit.Assert;

public class Test {
    
    public void test01(){
        BoundedBuffer<Integer> boundedBuffer = new BoundedBuffer<Integer>(10);
        Assert.assertTrue(boundedBuffer.isEmpty());
        Assert.assertFalse(boundedBuffer.isFull());
    }
    @org.junit.Test
    public void test02() throws InterruptedException{
        BoundedBuffer<Integer> boundedBuffer = new BoundedBuffer<Integer>(10);
        
        for(int i=0;i<10;i++){
            boundedBuffer.put(i);
        }
        Assert.assertTrue(boundedBuffer.isFull());
        Assert.assertFalse(boundedBuffer.isEmpty());
        System.out.println(boundedBuffer.isFull());
    }
}