ArrayBlockingQueue－我们到底能走多远系列(42)

我们到底能走多远系列(42)

java.util.Queue

add(e)

offer(e)

put(e)

offer(e, time, unit)

remove()

poll()

take()

poll(time, unit)

element()

peek()

// 队列存放元素的容器
final Object[] items;

// 下一次读取或移除的位置
int takeIndex;

// 存放下一个放入元素的位置
int putIndex;

// 队列里有效元素的数量
int count;

// 所有访问的保护锁
final ReentrantLock lock;

// 等待获取的条件
private final Condition notEmpty;

// 等待放入的条件
private final Condition notFull;

// 指针前移
final int inc(int i) {
return (++i == items.length) ? 0 : i;
}

// 指针后移
final int dec(int i) {
return ((i == 0) ? items.length : i) - 1;
}

public void put(E e) throws InterruptedException {
checkNotNull(e);//不能放null
final ReentrantLock lock = this.lock;//先把锁赋给final修饰的局部变量
// 在JUC的很多类里，都会看到这种写法：把类的属性赋值给方法内的用final修饰一个变量。
// 这是因为类的属性是存放在堆里的，方法内的变量是存放在方法栈上的，访问方法栈比访问堆要快。
// 在这里，this.lock属性要访问两次，通过赋值给方法的局部变量，就节省了一次堆的访问。
// 其他的类属性只访问一次就不需要这样处理了。
lock.lockInterruptibly();//加锁
try {
//循环保证避免避免虚假唤醒，虚假唤醒就是此事如果有多个线程都wait，
　　　　　　　//而被同时唤醒时都会去执行下面的insert
//如果在while循环中，那么唤醒后先判断count大小，来确定是继续wait还是insert。
while (count == items.length)
notFull.await();//阻塞线程
insert(e);
} finally {
lock.unlock();//释放锁
}
}

public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();
return extract();
} finally {
lock.unlock();
}
}

private void insert(E x) {
items[putIndex] = x;// 1,存值，非常简便
putIndex = inc(putIndex);//2,移动下标，使用inc方法
++count;//3,增加元素总数
notEmpty.signal();//4,通知在非空条件上等待的读线程
}

private E extract() {
final Object[] items = this.items;//先将类变量赋给方法变量，前面提过这个用处
E x = this.<E>cast(items[takeIndex]);
items[takeIndex] = null;
takeIndex = inc(takeIndex);
--count;
notFull.signal();
return x;
}