今日整理

最新推荐文章于 2024-06-30 15:50:01 发布

Em_dark

最新推荐文章于 2024-06-30 15:50:01 发布

阅读量305

点赞数

分类专栏：随笔

本文链接：https://blog.csdn.net/Em_dark/article/details/79382950

版权

随笔专栏收录该内容

35 篇文章 0 订阅

订阅专栏

现在整理一下吧

Array BlockingQueue 手动实现一下吧

首先构造

//有如下定义
/** The queued items  */  
private final E[] items;  
/** items index for next take, poll or remove */  
private int takeIndex;  
/** items index for next put, offer, or add. */  
private int putIndex;  
/** Number of items in the queue */  
private int count;  

/* 
 * Concurrency control uses the classic two-condition algorithm 
 * found in any textbook. 
 */  

/** Main lock guarding all access */  
private final ReentrantLock lock;  
/** Condition for waiting takes */  
private final Condition notEmpty;  
/** Condition for waiting puts */  
private final Condition notFull;
//初始化capacity 初始化队列容量 锁是否公平 
public ArrayBlockingQueue(int capacity, boolean fair) {  

       if (capacity <= 0)  
           throw new IllegalArgumentException();  
       this.items = (E[]) new Object[capacity];  
       lock = new ReentrantLock(fair);  
       notEmpty = lock.newCondition();  
       notFull =  lock.newCondition();  
   }
//put方法
public void put(E e) throws InterruptedException {  
        //不能存放 null  元素  
        if (e == null) throw new NullPointerException();  
        final E[] items = this.items;   //数组队列  
        final ReentrantLock lock = this.lock;  
        //加锁  
        lock.lockInterruptibly();  
        try {  
            try {  
                //当队列满时，调用notFull.await()方法，使该线程阻塞。  
                //直到take掉某个元素后，调用notFull.signal()方法激活该线程。  
                while (count == items.length)  
                    notFull.await();  
            } catch (InterruptedException ie) {  
                notFull.signal(); // propagate to non-interrupted thread  
                throw ie;  
            }  
            //把元素 e 插入到队尾  
            insert(e);  
        } finally {  
            //解锁  
            lock.unlock();  
        }  
    }  
//insert 方法
 private void insert(E x) {  
      items[putIndex] = x;    
//下标加1或者等于0  
      putIndex = inc(putIndex);  
      ++count;  //计数加1  
//若有take()线程陷入阻塞，则该操作激活take()线程,继续进行取元素操作。  
//若没有take()线程陷入阻塞，则该操作无意义。  
      notEmpty.signal();  
  }  

**  
   * Circularly increment i.  
   */  
  final int inc(int i) {  
//此处可以看到使用了循环队列  
      return (++i == items.length)? 0 : i;  
  }  

//take方法
public E take() throws InterruptedException {  
        final ReentrantLock lock = this.lock;  
        lock.lockInterruptibly();  //加锁  
        try {  
            try {  
                //当队列空时，调用notEmpty.await()方法，使该线程阻塞。  
                //直到take掉某个元素后，调用notEmpty.signal()方法激活该线程。  
                while (count == 0)  
                    notEmpty.await();  
            } catch (InterruptedException ie) {  
                notEmpty.signal(); // propagate to non-interrupted thread  
                throw ie;  
            }  
            //取出队头元素  
            E x = extract();  
            return x;  
        } finally {  
            lock.unlock();  //解锁  
        }  
    }
  private E extract() {  
        final E[] items = this.items;  
        E x = items[takeIndex];  
        items[takeIndex] = null;  
        takeIndex = inc(takeIndex);  
        --count;  
        notFull.signal();  
        return x;  
    }

设计模式方面

//单例
public class Singleton {
     private static final Singleton singleton = new Singleton();
//限制产生多个对象
     private Singleton(){
     }
     //通过该方法获得实例对象
     public static Singleton getSingleton(){
             return singleton;
     }  
     //类中其他方法，尽量是static
     public static void doSomething(){
     }
}