パートのブログ、私たちは、スレッドプールのワークキュー、タスクキューについての話します
private final BlockingQueue<Runnable> workQueue;
复制代码あなたは、私たちが実際に同時キューBlockingQueueの実装の様々なを使用し、BlockingQueueのインターフェイスで、BlockingQueueのタイプを見ることができます。私たちは今、それをチェックアウトして子供を一つずつ持っています
BlockingQueueの
public interface BlockingQueue<E> extends Queue<E> {}
复制代码BlockingQueueのはとてもFIFOを満たすために、キューから継承されました。BlockingQueueのフロント導入源が多い、BlockingQueueの挿入操作は、除去動作、操作要素は異なるシナリオのために使用される4つの異なる方法を提供取得すると結論：1、例外がスローされ、図2に示すように、特殊な戻り値を（特定の操作に応じて、偽/ヌルまたは真）、操作が成功するまで3、このブロックは、操作を待って、図4に示すように、このブロックは、指定された時間またはタイムアウトの成功までの動作を待っています
BlockingQueueのは、NULL値が受け入れられません挿入しました
コンシューマ・キュー - BlockingQueueのは、プロデューサーを達成するように設計されています。
BlockingQueueのは達成スレッドセーフですが、のaddAll、のcontainsAll、retainAll、およびのremoveAllとしてコレクション操作の大部分は、必ずしもアトミック操作ではありません。例外の中央がスローされた後、いくつかの要素を追加することが可能であるのaddAll（c）は、次いでBlockingQueueのいくつかの要素は、特定の実装に応じて、これは許容され、追加されています。
まあ、これは単なるインターフェイスで、我々はあなたがそれを達成するために行かなければならない、ADO
ArrayBlockingQueue
名前が示すように、それは根本的な実装である配列であります
// 用于存放元素的数组
final Object[] items;
// 下一次读取操作的位置
int takeIndex;
// 下一次写入操作的位置
int putIndex;
// 队列中元素数量
int count;
// 锁保证出入队原子性
final ReentrantLock lock;
// 出队同步，等待满足非空
private final Condition notEmpty;
// 入队同步，等待满足非满
private final Condition notFull;
复制代码コンストラクタ
public ArrayBlockingQueue(int capacity) {
this(capacity, false);
}
public ArrayBlockingQueue(int capacity, boolean fair) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = new Object[capacity];
lock = new ReentrantLock(fair);
notEmpty = lock.newCondition();
notFull = lock.newCondition();
}
复制代码デフォルトは非ReentrantLockの公平ロックを使用することで、見ることができます。
提供
public boolean offer(E e) {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lock();
try {
if (count == items.length)
return false;
else {
enqueue(e);
return true;
}
} finally {
lock.unlock();
}
}
private void enqueue(E x) {
final Object[] items = this.items;
// 元素入队
items[putIndex] = x;
// putIndex达到最大，调整
if (++putIndex == items.length)
// 队列前边的已被取走，所以putIndex达到最大可以再从0开始
putIndex = 0;
count++;
// 此时满足非空，可以唤醒一个notEmpty等待队列上的元素
notEmpty.signal();
}
复制代码- null以外の要素を確認してください
- ロックを取得します。
- それ以外の場合は、成功した追加、trueを返し、キューがいっぱいになっている場合、それは失敗を追加し、falseを返します
- ロックが解除され、リリースには、フロントロックのセマンティクスは、バックメインメモリへの共有変数の値ブラシを変更すると
要素の数が代わりにPUT / takeindex解析を使用しての、キューフルカウントに等しいことに注意してください
プット
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == items.length)
// 不满足非满，等待
notFull.await();
enqueue(e);
} finally {
lock.unlock();
}
}
复制代码キューが条件で、キュー内のハングを阻止する上でいっぱいになった場合は、何も言うことはありませんnotFull
投票
public E poll() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return (count == 0) ? null : dequeue();
} finally {
lock.unlock();
}
}
private E dequeue() {
final Object[] items = this.items;
@SuppressWarnings("unchecked")
E x = (E) items[takeIndex];
items[takeIndex] = null;
if (++takeIndex == items.length)
takeIndex = 0;
count--;
if (itrs != null)
itrs.elementDequeued();
// 此时取走一个元素，可以唤醒notFull上的一个线程
notFull.signal();
return x;
}
复制代码私は、ロックを取得し、その要素を奪う、takeIndexを更新し、botFullを目覚め、そして最終的にロックを解除するよりも、より多くの何も見ることができません。
取る
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();
return dequeue();
} finally {
lock.unlock();
}
}
复制代码比較すると、ポーリングは、キューを取ることはハング時間空ブロックで、世論調査では直接リターンヌルをブロックされていません
ピーク
public E peek() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return itemAt(takeIndex);
} finally {
lock.unlock();
}
}
final E itemAt(int i) {
return (E) items[i];
}
复制代码同じPEEKは直接キューヘッダ要素に戻され、ブロックされていない、空では、NULLを返します
サイズ
public int size() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return count;
} finally {
lock.unlock();
}
}
复制代码カウントするように戻るには、ロックを取得し、ロックが解除されます
ArrayBlockingQueueの概要
ArrayBlockingQueueしか取ると、それがブロックされているに言えば、他の方法は、直接復帰している、あなたはArrayBlockingQueueロック粒度は偉大なグローバルロックで見ることができますが、各動作の方法は、同期ハッシュテーブルに似たロックを取得する必要があり、だけでなく、サイズは正確な統計であるところ、この、の理由
LinkedBlockingQueue
あるいは、その名が示す、それはリストの一番下にあります
プロパティ
private final int capacity;
// 队列中元素数量
private final AtomicInteger count = new AtomicInteger();
// 链表头
transient Node<E> head;
// 链表尾
private transient Node<E> last;
// take，poll, peek 等读操作的方法需要获取到这个锁
private final ReentrantLock takeLock = new ReentrantLock();
// 等非空条件满足的condition
private final Condition notEmpty = takeLock.newCondition();
// put, offer 等写操作的方法需要获取到这个锁
private final ReentrantLock putLock = new ReentrantLock();
// 等不满条件满足的condition
private final Condition notFull = putLock.newCondition();
复制代码私たちは、書き込みロックがあることを確認し、ロックを読んで、その操作は、それを読むの間で書き込み、その後、書き込み操作間の同時実行の問題の間で読む必要はありませんでしょうか？私たちは下で導入しました
コンストラクタ
public LinkedBlockingQueue() {
this(Integer.MAX_VALUE);
}
public LinkedBlockingQueue(int capacity) {
if (capacity <= 0) throw new IllegalArgumentException();
this.capacity = capacity;
last = head = new Node<E>(null);
}
复制代码コンストラクタは、ヘッドノード、キューは2つの要素を持つことになりますチームへの最初の要素を初期化します。要素を読み込み、常にヘッドノードの背後にあるノードを取得。カウント値COUNTは、ヘッドノードを含めていません。
プット
public void put(E e) throws InterruptedException {
if (e == null) throw new NullPointerException();
int c = -1;
Node<E> node = new Node<E>(e);
final ReentrantLock putLock = this.putLock;
final AtomicInteger count = this.count;
putLock.lockInterruptibly();
try {
// 如果队列满了，等待notFull条件满足
while (count.get() == capacity) {
notFull.await();
}
// 满足notFull，新增节点入队
enqueue(node);
c = count.getAndIncrement();
if (c + 1 < capacity)
// 如果此时仍然没满，唤醒等待在notFull上的一个线程
notFull.signal();
} finally {
putLock.unlock();
}
if (c == 0)
// c==0即元素入队前是空的，那么所有的读线程都在等待 notEmpty 这个条件，等待唤醒，这里做一次唤醒操作
signalNotEmpty();
}
private void enqueue(Node<E> node) {
// 让last指向新增元素，注意是在获取锁的情况下进行的，不存在并发问题
last = last.next = node;
}
复制代码キューが不満を待つことがいっぱいの場合は、それがチームの中に条件を満たしています。
取る
public E take() throws InterruptedException {
E x;
int c = -1;
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
takeLock.lockInterruptibly();
try {
while (count.get() == 0) {
notEmpty.await();
}
x = dequeue();
c = count.getAndDecrement();
if (c > 1)
notEmpty.signal();
} finally {
takeLock.unlock();
}
c==capacity的话，此时去走一个，就可以唤醒阻塞在notFull上的线程了
if (c == capacity)
signalNotFull();
return x;
}
// 这里直接把头节点置null，且指向自己，头节点的next值为null，变为新的头节点
private E dequeue() {
Node<E> h = head;
Node<E> first = h.next;
h.next = h; // help GC
head = first;
E x = first.item;
first.item = null;
return x;
}
复制代码キューが空待ち空でない場合は、条件を満足するキューの先頭を削除
サイズ
public int size() {
return count.get();
}
复制代码カウントは非常に正確ではありません。
他の同様の方法は、もはやブロックされていません
LinkedBlockingQueueの概要
エンキューおよびデキューを同時に行うことができるように内部LinkedBlockingQueueは、それぞれヘッド及びテイルノードエンキューおよびデキュー操作、2つのロックを使用して、単一のリンクリストによって実現します。
SynchronousQueue
名前は、同期キューを提案し続けて、何を同期していますか？これは、スレッドがキューに要素を書いているとき、書き込み操作がすぐに戻らないことをいい、あなたは離れて、この要素に別のスレッドを待つ必要があります。読者のスレッドが読み出し動作を行うために、同じトークン、同じ書き込み動作は、一致するスレッドを書くことが必要です。ここでの同期が指しスレッドがスレッドを同期する必要が読み取りと書き込み、読み出し書き込みスレッドに一致するスレッドを。
このキューが存在しないので、実際には、それは、要素を格納するために、任意のスペース（ないもの）を提供していません。データが消費されるのを待っているキューに書き込まれたのではなく、スレッドの書き込みからスレッドに読まなければなりません。
コンストラクタ
public SynchronousQueue(boolean fair) {
transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
}
复制代码これはしばらく見て何かがあるとして、あなたは、それが公正な初期化TransferQueueあれば、そうでない場合はTransferStackを初期化ロック、公正で公平である場所を推測することができ、実際に転写手段を開始され、見て、それをロックすることができます。
古いルールは、古いルックPUT /それを取ります
プット
// 写入值
public void put(E o) throws InterruptedException {
if (o == null) throw new NullPointerException();
if (transferer.transfer(o, false, 0) == null) { // 1
Thread.interrupted();
throw new InterruptedException();
}
}
// 读取值并移除
public E take() throws InterruptedException {
Object e = transferer.transfer(null, false, 0); // 2
if (e != null)
return (E)e;
Thread.interrupted();
throw new InterruptedException();
}
复制代码/置く呼び出しは、最初のパラメータがNULL値であることを除いて、内部テイクTransferer.transfer（...）メソッドです。
我々は置く（E 0）を書き、参照および操作は、最初の引数がNULL値であることを除いて、（）が呼び出されTransferer.transfer（...）メソッドを取るお読みください。のは、デザインのアイデア転送を見てみましょう、基本的なアルゴリズムは次のとおりです。キューが空の場合、このメソッドは、一貫性のある呼び出されたとき、またはキューノードと、現在の操作などの操作の現在のスレッドタイプが（キューながら、put操作であります要素も）、スレッドを作成しています。この場合、現在のスレッドが待機キューに追加することができます。ノードがある場合（例えば、キュースレッドを読み込み、現在のスレッドは、スレッドの書き込み動作、およびその逆である）キュー待ち、現在の動作を一致させることができます。この場合、HOL待ち行列に一致する、対応するデータを返すデキュー。実際にはキューが空でない場合、非表示の状態は、そこに満たされています、確かにノードの同じ型でいずれかの読み取りまたは書き込み操作をされています。これは、最終的に依存したスレッドのバックログを読み、またはスレッドのバックログを書くことです。;待機中の男性の束がある場合は、その後、彼は待ち行列の後ろにルーティングされる必要があり、女性の束であることが判明した場合、人がいなかった場合は男の上には、その後、彼は待つ必要がある：私たちは、男性と女性のペアのシーンがあることを前提とすることができますキューで、その後、彼は直接女性の鼻のチームヘッドが主導しています。
このキュー自体はほとんど使用されませんので、この子のためのソースコードは、私たちは十分に理解して何の上に、導入されていない、とだけスレッドプールが使用されます。
PriorityBlockingQueue
サイズを比較するために、関連する優先順位を実装するためのプライオリティキューは、キューオブジェクトの挿入は、クラスのサイズを比較しなければなりません。同じことは、ヌルを挿入することはできません。
実際には、そう置く方法がブロックされません、操作のサポートの拡張、彼のサイズは固定されていないため、彼は、アンバウンド形式のキューであるということができます
プロパティ
// 构造方法中，如果不指定大小的话，默认大小为 11
private static final int DEFAULT_INITIAL_CAPACITY = 11;
// 数组的最大容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// 这个就是存放数据的数组
private transient Object[] queue;
// 队列当前大小
private transient int size;
// 大小比较器，如果按照自然序排序，那么此属性可设置为 null
private transient Comparator<? super E> comparator;
// 并发控制所用的锁，所有的 public 且涉及到线程安全的方法，都必须先获取到这个锁
private final ReentrantLock lock;
private final Condition notEmpty;
// 这个也是用于锁，用于数组扩容的时候，需要先获取到这个锁，才能进行扩容操作
// 其使用 CAS 操作
private transient volatile int allocationSpinLock;
复制代码コンストラクタ
// 默认构造方法，采用默认值(11)来进行初始化
public PriorityBlockingQueue() {
this(DEFAULT_INITIAL_CAPACITY, null);
}
// 指定数组的初始大小
public PriorityBlockingQueue(int initialCapacity) {
this(initialCapacity, null);
}
// 指定比较器
public PriorityBlockingQueue(int initialCapacity,
Comparator<? super E> comparator) {
if (initialCapacity < 1)
throw new IllegalArgumentException();
this.lock = new ReentrantLock();
this.notEmpty = lock.newCondition();
this.comparator = comparator;
this.queue = new Object[initialCapacity];
}
复制代码拡張
private void tryGrow(Object[] array, int oldCap) {
// 释放了原来的独占锁 lock，这样的话，扩容操作和读操作可以同时进行，提高吞吐量
lock.unlock();
Object[] newArray = null;
// 获取到allocationSpinLock才能进行数组扩容
if (allocationSpinLock == 0 &&
UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset,
0, 1)) {
try {
// 如果节点个数小于 64，那么增加的 oldCap + 2 的容量
// 如果节点数大于等于 64，那么增加 oldCap 的一半
// 所以节点数较小时，增长得快一些
int newCap = oldCap + ((oldCap < 64) ?
(oldCap + 2) :
(oldCap >> 1));
// 可能溢出
if (newCap - MAX_ARRAY_SIZE > 0) {
int minCap = oldCap + 1;
if (minCap < 0 || minCap > MAX_ARRAY_SIZE)
throw new OutOfMemoryError();
newCap = MAX_ARRAY_SIZE;
}
// 如果 queue != array，那么说明有其他线程给 queue 分配了其他的空间
if (newCap > oldCap && queue == array)
newArray = new Object[newCap];
} finally {
allocationSpinLock = 0;
}
}
// 其他线程做了扩容操作
if (newArray == null)
Thread.yield();
lock.lock();
// 将原来数组中的元素复制到新分配的大数组中
if (newArray != null && queue == array) {
queue = newArray;
System.arraycopy(array, 0, newArray, 0, oldCap);
}
}
复制代码プット
public void put(E e) {
// 直接调用 offer 方法，在这里，put 方法不会阻塞
offer(e);
}
public boolean offer(E e) {
if (e == null)
throw new NullPointerException();
final ReentrantLock lock = this.lock;
// 首先获取到独占锁
lock.lock();
int n, cap;
Object[] array;
// 如果当前队列中的元素个数 >= 数组的大小，那么需要扩容了
while ((n = size) >= (cap = (array = queue).length))
tryGrow(array, cap);
try {
Comparator<? super E> cmp = comparator;
// 节点添加到二叉堆中
if (cmp == null)
siftUpComparable(n, e, array);
else
siftUpUsingComparator(n, e, array, cmp);
// 更新 size
size = n + 1;
// 唤醒等待的读线程
notEmpty.signal();
} finally {
lock.unlock();
}
return true;
}
复制代码あなたは、プロセスは非常に簡単です、参照ロックを取得し、要素を挿入し、バイナリヒープを調整し、限られたスペースに山ができ、ここではそれらを繰り返す、記事の詳細はありません書き戻します。
取る
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
// 独占锁
lock.lockInterruptibly();
E result;
try {
// dequeue 出队
while ( (result = dequeue()) == null)
notEmpty.await();
} finally {
lock.unlock();
}
return result;
}
复制代码同じことは、キューが空でない場合は、空が直接出て、注意もバイナリヒープを調整する必要がある場合、その後、待機する必要があり、排他ロックを取得することです。
DelayQueue
名前が示すように、それは遅延キューで、それが何を意味するのでしょうか？これは、各要素がキュー時間が経過したが、買収によるキュー要素は、期限切れの要素を取得することができます
これは、次のシナリオに適用することができます。
- このキャッシュ要素が有効なキューで、一度取得し、クエリキュースレッドを開いて使用したデザイン・キャッシング・システムは、それがキャッシュされるまで有効を表し、
- あなたは、このようなTimeQueueなどのタスクを実行するために得れば、時間を節約するために定期的にタスクをスケジュールするこのキューを使用し、その日のタスクを実行します
キュー遅延要素は、インターフェースを実装する必要があり、そして、compareToメソッド指定された要素の順序を実装する必要があり、その結果、最も長いキューの最後の遅延素子
public interface Delayed extends Comparable<Delayed> {
long getDelay(TimeUnit unit);
}
复制代码この方法は、要素が閉塞に遅延時間に達していない場合は、キュー内の遅延素子を得るために、多くの時間が利用可能であるか、現在の要素を返します。
概要
それは非常に、非常に長い記事です。。。
- 非常に良い選択である消費者のモデル、 - 私たちはプロデューサーを使用したい場合はArrayBlockingQueue下では、配列、有界キューです。
- LinkedBlockingQueue階がリストされ、使用することを無制限と有界キューとして使用することができますので、我々はそれがアンバウンド形式のキューではないと思います。
- 任意の要素を格納するスペースのないSynchronousQueue自体は、モードと非公平公正モードの使用を選択することができます。
- PriorityBlockingQueue無制限キュー、アレイベースの、バイナリヒープデータ構造、ツリーは、最初の配列のルート・ノードは常に最小です。
- DelayQueueは、基礎となる実装として優先度つきキューを使用するだけで取得要素の有効期限を遅らせることができ、また、アンバウンド形式のブロッキングキューです
公共ませプログラマんErgou
一日あたりのオリジナル記事、学習の交換をして