Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
openanolis
dragonwell8_jdk
提交
bb129db0
D
dragonwell8_jdk
项目概览
openanolis
/
dragonwell8_jdk
通知
4
Star
2
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
D
dragonwell8_jdk
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
提交
bb129db0
编写于
11月 08, 2009
作者:
O
ohair
浏览文件
操作
浏览文件
下载
差异文件
Merge
上级
3f8528a7
ecd79008
变更
48
展开全部
隐藏空白更改
内联
并排
Showing
48 changed file
with
8245 addition
and
65 deletion
+8245
-65
make/java/java/FILES_java.gmk
make/java/java/FILES_java.gmk
+9
-0
src/share/classes/java/util/AbstractList.java
src/share/classes/java/util/AbstractList.java
+2
-3
src/share/classes/java/util/AbstractQueue.java
src/share/classes/java/util/AbstractQueue.java
+2
-4
src/share/classes/java/util/HashMap.java
src/share/classes/java/util/HashMap.java
+2
-6
src/share/classes/java/util/HashSet.java
src/share/classes/java/util/HashSet.java
+2
-2
src/share/classes/java/util/Random.java
src/share/classes/java/util/Random.java
+12
-0
src/share/classes/java/util/concurrent/ArrayBlockingQueue.java
...hare/classes/java/util/concurrent/ArrayBlockingQueue.java
+2
-2
src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java
...e/classes/java/util/concurrent/ConcurrentLinkedQueue.java
+2
-2
src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java
...e/classes/java/util/concurrent/ConcurrentSkipListMap.java
+1
-1
src/share/classes/java/util/concurrent/CountDownLatch.java
src/share/classes/java/util/concurrent/CountDownLatch.java
+2
-1
src/share/classes/java/util/concurrent/ExecutorService.java
src/share/classes/java/util/concurrent/ExecutorService.java
+4
-4
src/share/classes/java/util/concurrent/ForkJoinPool.java
src/share/classes/java/util/concurrent/ForkJoinPool.java
+1988
-0
src/share/classes/java/util/concurrent/ForkJoinTask.java
src/share/classes/java/util/concurrent/ForkJoinTask.java
+1292
-0
src/share/classes/java/util/concurrent/ForkJoinWorkerThread.java
...re/classes/java/util/concurrent/ForkJoinWorkerThread.java
+827
-0
src/share/classes/java/util/concurrent/LinkedTransferQueue.java
...are/classes/java/util/concurrent/LinkedTransferQueue.java
+1270
-0
src/share/classes/java/util/concurrent/Phaser.java
src/share/classes/java/util/concurrent/Phaser.java
+1042
-0
src/share/classes/java/util/concurrent/RecursiveAction.java
src/share/classes/java/util/concurrent/RecursiveAction.java
+179
-0
src/share/classes/java/util/concurrent/RecursiveTask.java
src/share/classes/java/util/concurrent/RecursiveTask.java
+97
-0
src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java
...ses/java/util/concurrent/ScheduledThreadPoolExecutor.java
+8
-0
src/share/classes/java/util/concurrent/ThreadLocalRandom.java
...share/classes/java/util/concurrent/ThreadLocalRandom.java
+228
-0
src/share/classes/java/util/concurrent/TransferQueue.java
src/share/classes/java/util/concurrent/TransferQueue.java
+161
-0
src/share/classes/java/util/concurrent/locks/Condition.java
src/share/classes/java/util/concurrent/locks/Condition.java
+2
-2
src/share/classes/java/util/concurrent/package-info.java
src/share/classes/java/util/concurrent/package-info.java
+37
-10
test/java/util/Collection/BiggernYours.java
test/java/util/Collection/BiggernYours.java
+4
-4
test/java/util/Collection/IteratorAtEnd.java
test/java/util/Collection/IteratorAtEnd.java
+1
-1
test/java/util/Collection/MOAT.java
test/java/util/Collection/MOAT.java
+1
-1
test/java/util/Collections/CheckedNull.java
test/java/util/Collections/CheckedNull.java
+1
-1
test/java/util/Collections/RacingCollections.java
test/java/util/Collections/RacingCollections.java
+1
-1
test/java/util/PriorityQueue/RemoveContains.java
test/java/util/PriorityQueue/RemoveContains.java
+1
-1
test/java/util/concurrent/BlockingQueue/CancelledProducerConsumerLoops.java
...current/BlockingQueue/CancelledProducerConsumerLoops.java
+25
-1
test/java/util/concurrent/BlockingQueue/LastElement.java
test/java/util/concurrent/BlockingQueue/LastElement.java
+1
-1
test/java/util/concurrent/BlockingQueue/MultipleProducersSingleConsumerLoops.java
...t/BlockingQueue/MultipleProducersSingleConsumerLoops.java
+25
-1
test/java/util/concurrent/BlockingQueue/OfferDrainToLoops.java
...java/util/concurrent/BlockingQueue/OfferDrainToLoops.java
+2
-3
test/java/util/concurrent/BlockingQueue/PollMemoryLeak.java
test/java/util/concurrent/BlockingQueue/PollMemoryLeak.java
+1
-1
test/java/util/concurrent/BlockingQueue/ProducerConsumerLoops.java
.../util/concurrent/BlockingQueue/ProducerConsumerLoops.java
+25
-1
test/java/util/concurrent/BlockingQueue/SingleProducerMultipleConsumerLoops.java
...nt/BlockingQueue/SingleProducerMultipleConsumerLoops.java
+25
-1
test/java/util/concurrent/ConcurrentQueues/ConcurrentQueueLoops.java
...til/concurrent/ConcurrentQueues/ConcurrentQueueLoops.java
+1
-1
test/java/util/concurrent/ConcurrentQueues/GCRetention.java
test/java/util/concurrent/ConcurrentQueues/GCRetention.java
+2
-2
test/java/util/concurrent/ConcurrentQueues/IteratorWeakConsistency.java
.../concurrent/ConcurrentQueues/IteratorWeakConsistency.java
+1
-1
test/java/util/concurrent/ConcurrentQueues/OfferRemoveLoops.java
...va/util/concurrent/ConcurrentQueues/OfferRemoveLoops.java
+2
-3
test/java/util/concurrent/ConcurrentQueues/RemovePollRace.java
...java/util/concurrent/ConcurrentQueues/RemovePollRace.java
+2
-2
test/java/util/concurrent/Phaser/Arrive.java
test/java/util/concurrent/Phaser/Arrive.java
+94
-0
test/java/util/concurrent/Phaser/Basic.java
test/java/util/concurrent/Phaser/Basic.java
+407
-0
test/java/util/concurrent/ScheduledThreadPoolExecutor/DelayOverflow.java
...concurrent/ScheduledThreadPoolExecutor/DelayOverflow.java
+11
-0
test/java/util/concurrent/forkjoin/Integrate.java
test/java/util/concurrent/forkjoin/Integrate.java
+265
-0
test/java/util/concurrent/forkjoin/NQueensCS.java
test/java/util/concurrent/forkjoin/NQueensCS.java
+174
-0
test/java/util/concurrent/locks/ReentrantLock/CancelledLockLoops.java
...il/concurrent/locks/ReentrantLock/CancelledLockLoops.java
+1
-1
test/java/util/concurrent/locks/ReentrantReadWriteLock/RWMap.java
...a/util/concurrent/locks/ReentrantReadWriteLock/RWMap.java
+1
-0
未找到文件。
make/java/java/FILES_java.gmk
浏览文件 @
bb129db0
...
...
@@ -286,11 +286,18 @@ JAVA_JAVA_java = \
java/util/concurrent/ExecutorService.java \
java/util/concurrent/ExecutorCompletionService.java \
java/util/concurrent/Executors.java \
java/util/concurrent/ForkJoinPool.java \
java/util/concurrent/ForkJoinTask.java \
java/util/concurrent/ForkJoinWorkerThread.java \
java/util/concurrent/Future.java \
java/util/concurrent/FutureTask.java \
java/util/concurrent/LinkedBlockingDeque.java \
java/util/concurrent/LinkedBlockingQueue.java \
java/util/concurrent/LinkedTransferQueue.java \
java/util/concurrent/Phaser.java \
java/util/concurrent/PriorityBlockingQueue.java \
java/util/concurrent/RecursiveAction.java \
java/util/concurrent/RecursiveTask.java \
java/util/concurrent/RejectedExecutionException.java \
java/util/concurrent/RejectedExecutionHandler.java \
java/util/concurrent/RunnableFuture.java \
...
...
@@ -301,9 +308,11 @@ JAVA_JAVA_java = \
java/util/concurrent/Semaphore.java \
java/util/concurrent/SynchronousQueue.java \
java/util/concurrent/ThreadFactory.java \
java/util/concurrent/ThreadLocalRandom.java \
java/util/concurrent/ThreadPoolExecutor.java \
java/util/concurrent/TimeUnit.java \
java/util/concurrent/TimeoutException.java \
java/util/concurrent/TransferQueue.java \
java/util/concurrent/atomic/AtomicBoolean.java \
java/util/concurrent/atomic/AtomicInteger.java \
java/util/concurrent/atomic/AtomicIntegerArray.java \
...
...
src/share/classes/java/util/AbstractList.java
浏览文件 @
bb129db0
...
...
@@ -256,9 +256,8 @@ public abstract class AbstractList<E> extends AbstractCollection<E> implements L
public
boolean
addAll
(
int
index
,
Collection
<?
extends
E
>
c
)
{
rangeCheckForAdd
(
index
);
boolean
modified
=
false
;
Iterator
<?
extends
E
>
e
=
c
.
iterator
();
while
(
e
.
hasNext
())
{
add
(
index
++,
e
.
next
());
for
(
E
e
:
c
)
{
add
(
index
++,
e
);
modified
=
true
;
}
return
modified
;
...
...
src/share/classes/java/util/AbstractQueue.java
浏览文件 @
bb129db0
...
...
@@ -183,11 +183,9 @@ public abstract class AbstractQueue<E>
if
(
c
==
this
)
throw
new
IllegalArgumentException
();
boolean
modified
=
false
;
Iterator
<?
extends
E
>
e
=
c
.
iterator
();
while
(
e
.
hasNext
())
{
if
(
add
(
e
.
next
()))
for
(
E
e
:
c
)
if
(
add
(
e
))
modified
=
true
;
}
return
modified
;
}
...
...
src/share/classes/java/util/HashMap.java
浏览文件 @
bb129db0
...
...
@@ -448,10 +448,8 @@ public class HashMap<K,V>
}
private
void
putAllForCreate
(
Map
<?
extends
K
,
?
extends
V
>
m
)
{
for
(
Iterator
<?
extends
Map
.
Entry
<?
extends
K
,
?
extends
V
>>
i
=
m
.
entrySet
().
iterator
();
i
.
hasNext
();
)
{
Map
.
Entry
<?
extends
K
,
?
extends
V
>
e
=
i
.
next
();
for
(
Map
.
Entry
<?
extends
K
,
?
extends
V
>
e
:
m
.
entrySet
())
putForCreate
(
e
.
getKey
(),
e
.
getValue
());
}
}
/**
...
...
@@ -536,10 +534,8 @@ public class HashMap<K,V>
resize
(
newCapacity
);
}
for
(
Iterator
<?
extends
Map
.
Entry
<?
extends
K
,
?
extends
V
>>
i
=
m
.
entrySet
().
iterator
();
i
.
hasNext
();
)
{
Map
.
Entry
<?
extends
K
,
?
extends
V
>
e
=
i
.
next
();
for
(
Map
.
Entry
<?
extends
K
,
?
extends
V
>
e
:
m
.
entrySet
())
put
(
e
.
getKey
(),
e
.
getValue
());
}
}
/**
...
...
src/share/classes/java/util/HashSet.java
浏览文件 @
bb129db0
...
...
@@ -280,8 +280,8 @@ public class HashSet<E>
s
.
writeInt
(
map
.
size
());
// Write out all elements in the proper order.
for
(
Iterator
i
=
map
.
keySet
().
iterator
();
i
.
hasNext
();
)
s
.
writeObject
(
i
.
next
()
);
for
(
E
e
:
map
.
keySet
()
)
s
.
writeObject
(
e
);
}
/**
...
...
src/share/classes/java/util/Random.java
浏览文件 @
bb129db0
...
...
@@ -50,6 +50,18 @@ import sun.misc.Unsafe;
* <p>
* Many applications will find the method {@link Math#random} simpler to use.
*
* <p>Instances of {@code java.util.Random} are threadsafe.
* However, the concurrent use of the same {@code java.util.Random}
* instance across threads may encounter contention and consequent
* poor performance. Consider instead using
* {@link java.util.concurrent.ThreadLocalRandom} in multithreaded
* designs.
*
* <p>Instances of {@code java.util.Random} are not cryptographically
* secure. Consider instead using {@link java.security.SecureRandom} to
* get a cryptographically secure pseudo-random number generator for use
* by security-sensitive applications.
*
* @author Frank Yellin
* @since 1.0
*/
...
...
src/share/classes/java/util/concurrent/ArrayBlockingQueue.java
浏览文件 @
bb129db0
...
...
@@ -218,8 +218,8 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
if
(
capacity
<
c
.
size
())
throw
new
IllegalArgumentException
();
for
(
Iterator
<?
extends
E
>
it
=
c
.
iterator
();
it
.
hasNext
();
)
add
(
it
.
next
()
);
for
(
E
e
:
c
)
add
(
e
);
}
/**
...
...
src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java
浏览文件 @
bb129db0
...
...
@@ -250,8 +250,8 @@ public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
* of its elements are null
*/
public
ConcurrentLinkedQueue
(
Collection
<?
extends
E
>
c
)
{
for
(
Iterator
<?
extends
E
>
it
=
c
.
iterator
();
it
.
hasNext
();
)
add
(
it
.
next
()
);
for
(
E
e
:
c
)
add
(
e
);
}
// Have to override just to update the javadoc
...
...
src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java
浏览文件 @
bb129db0
...
...
@@ -895,7 +895,7 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
if
(
n
!=
null
)
{
Node
<
K
,
V
>
f
=
n
.
next
;
if
(
n
!=
b
.
next
)
// inconsistent read
break
;
;
break
;
Object
v
=
n
.
value
;
if
(
v
==
null
)
{
// n is deleted
n
.
helpDelete
(
b
,
f
);
...
...
src/share/classes/java/util/concurrent/CountDownLatch.java
浏览文件 @
bb129db0
...
...
@@ -148,7 +148,8 @@ import java.util.concurrent.atomic.*;
*
* </pre>
*
* <p>Memory consistency effects: Actions in a thread prior to calling
* <p>Memory consistency effects: Until the count reaches
* zero, actions in a thread prior to calling
* {@code countDown()}
* <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
* actions following a successful return from a corresponding
...
...
src/share/classes/java/util/concurrent/ExecutorService.java
浏览文件 @
bb129db0
...
...
@@ -332,8 +332,8 @@ public interface ExecutorService extends Executor {
* @param tasks the collection of tasks
* @return the result returned by one of the tasks
* @throws InterruptedException if interrupted while waiting
* @throws NullPointerException if tasks or any
of its elements
*
are
<tt>null</tt>
* @throws NullPointerException if tasks or any
element task
*
subject to execution is
<tt>null</tt>
* @throws IllegalArgumentException if tasks is empty
* @throws ExecutionException if no task successfully completes
* @throws RejectedExecutionException if tasks cannot be scheduled
...
...
@@ -356,8 +356,8 @@ public interface ExecutorService extends Executor {
* @param unit the time unit of the timeout argument
* @return the result returned by one of the tasks.
* @throws InterruptedException if interrupted while waiting
* @throws NullPointerException if tasks,
any of its elements, or
*
unit are
<tt>null</tt>
* @throws NullPointerException if tasks,
or unit, or any element
*
task subject to execution is
<tt>null</tt>
* @throws TimeoutException if the given timeout elapses before
* any task successfully completes
* @throws ExecutionException if no task successfully completes
...
...
src/share/classes/java/util/concurrent/ForkJoinPool.java
0 → 100644
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
src/share/classes/java/util/concurrent/ForkJoinTask.java
0 → 100644
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
src/share/classes/java/util/concurrent/ForkJoinWorkerThread.java
0 → 100644
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
src/share/classes/java/util/concurrent/LinkedTransferQueue.java
0 → 100644
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
src/share/classes/java/util/concurrent/Phaser.java
0 → 100644
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
src/share/classes/java/util/concurrent/RecursiveAction.java
0 → 100644
浏览文件 @
bb129db0
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
/*
* This file is available under and governed by the GNU General Public
* License version 2 only, as published by the Free Software Foundation.
* However, the following notice accompanied the original version of this
* file:
*
* Written by Doug Lea with assistance from members of JCP JSR-166
* Expert Group and released to the public domain, as explained at
* http://creativecommons.org/licenses/publicdomain
*/
package
java.util.concurrent
;
/**
* A recursive resultless {@link ForkJoinTask}. This class
* establishes conventions to parameterize resultless actions as
* {@code Void} {@code ForkJoinTask}s. Because {@code null} is the
* only valid value of type {@code Void}, methods such as join always
* return {@code null} upon completion.
*
* <p><b>Sample Usages.</b> Here is a sketch of a ForkJoin sort that
* sorts a given {@code long[]} array:
*
* <pre> {@code
* class SortTask extends RecursiveAction {
* final long[] array; final int lo; final int hi;
* SortTask(long[] array, int lo, int hi) {
* this.array = array; this.lo = lo; this.hi = hi;
* }
* protected void compute() {
* if (hi - lo < THRESHOLD)
* sequentiallySort(array, lo, hi);
* else {
* int mid = (lo + hi) >>> 1;
* invokeAll(new SortTask(array, lo, mid),
* new SortTask(array, mid, hi));
* merge(array, lo, hi);
* }
* }
* }}</pre>
*
* You could then sort {@code anArray} by creating {@code new
* SortTask(anArray, 0, anArray.length-1) } and invoking it in a
* ForkJoinPool. As a more concrete simple example, the following
* task increments each element of an array:
* <pre> {@code
* class IncrementTask extends RecursiveAction {
* final long[] array; final int lo; final int hi;
* IncrementTask(long[] array, int lo, int hi) {
* this.array = array; this.lo = lo; this.hi = hi;
* }
* protected void compute() {
* if (hi - lo < THRESHOLD) {
* for (int i = lo; i < hi; ++i)
* array[i]++;
* }
* else {
* int mid = (lo + hi) >>> 1;
* invokeAll(new IncrementTask(array, lo, mid),
* new IncrementTask(array, mid, hi));
* }
* }
* }}</pre>
*
* <p>The following example illustrates some refinements and idioms
* that may lead to better performance: RecursiveActions need not be
* fully recursive, so long as they maintain the basic
* divide-and-conquer approach. Here is a class that sums the squares
* of each element of a double array, by subdividing out only the
* right-hand-sides of repeated divisions by two, and keeping track of
* them with a chain of {@code next} references. It uses a dynamic
* threshold based on method {@code getSurplusQueuedTaskCount}, but
* counterbalances potential excess partitioning by directly
* performing leaf actions on unstolen tasks rather than further
* subdividing.
*
* <pre> {@code
* double sumOfSquares(ForkJoinPool pool, double[] array) {
* int n = array.length;
* Applyer a = new Applyer(array, 0, n, null);
* pool.invoke(a);
* return a.result;
* }
*
* class Applyer extends RecursiveAction {
* final double[] array;
* final int lo, hi;
* double result;
* Applyer next; // keeps track of right-hand-side tasks
* Applyer(double[] array, int lo, int hi, Applyer next) {
* this.array = array; this.lo = lo; this.hi = hi;
* this.next = next;
* }
*
* double atLeaf(int l, int h) {
* double sum = 0;
* for (int i = l; i < h; ++i) // perform leftmost base step
* sum += array[i] * array[i];
* return sum;
* }
*
* protected void compute() {
* int l = lo;
* int h = hi;
* Applyer right = null;
* while (h - l > 1 && getSurplusQueuedTaskCount() <= 3) {
* int mid = (l + h) >>> 1;
* right = new Applyer(array, mid, h, right);
* right.fork();
* h = mid;
* }
* double sum = atLeaf(l, h);
* while (right != null) {
* if (right.tryUnfork()) // directly calculate if not stolen
* sum += right.atLeaf(right.lo, right.hi);
* else {
* right.helpJoin();
* sum += right.result;
* }
* right = right.next;
* }
* result = sum;
* }
* }}</pre>
*
* @since 1.7
* @author Doug Lea
*/
public
abstract
class
RecursiveAction
extends
ForkJoinTask
<
Void
>
{
private
static
final
long
serialVersionUID
=
5232453952276485070L
;
/**
* The main computation performed by this task.
*/
protected
abstract
void
compute
();
/**
* Always returns null.
*/
public
final
Void
getRawResult
()
{
return
null
;
}
/**
* Requires null completion value.
*/
protected
final
void
setRawResult
(
Void
mustBeNull
)
{
}
/**
* Implements execution conventions for RecursiveActions.
*/
protected
final
boolean
exec
()
{
compute
();
return
true
;
}
}
src/share/classes/java/util/concurrent/RecursiveTask.java
0 → 100644
浏览文件 @
bb129db0
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
/*
* This file is available under and governed by the GNU General Public
* License version 2 only, as published by the Free Software Foundation.
* However, the following notice accompanied the original version of this
* file:
*
* Written by Doug Lea with assistance from members of JCP JSR-166
* Expert Group and released to the public domain, as explained at
* http://creativecommons.org/licenses/publicdomain
*/
package
java.util.concurrent
;
/**
* A recursive result-bearing {@link ForkJoinTask}.
*
* <p>For a classic example, here is a task computing Fibonacci numbers:
*
* <pre> {@code
* class Fibonacci extends RecursiveTask<Integer> {
* final int n;
* Fibonacci(int n) { this.n = n; }
* Integer compute() {
* if (n <= 1)
* return n;
* Fibonacci f1 = new Fibonacci(n - 1);
* f1.fork();
* Fibonacci f2 = new Fibonacci(n - 2);
* return f2.compute() + f1.join();
* }
* }}</pre>
*
* However, besides being a dumb way to compute Fibonacci functions
* (there is a simple fast linear algorithm that you'd use in
* practice), this is likely to perform poorly because the smallest
* subtasks are too small to be worthwhile splitting up. Instead, as
* is the case for nearly all fork/join applications, you'd pick some
* minimum granularity size (for example 10 here) for which you always
* sequentially solve rather than subdividing.
*
* @since 1.7
* @author Doug Lea
*/
public
abstract
class
RecursiveTask
<
V
>
extends
ForkJoinTask
<
V
>
{
private
static
final
long
serialVersionUID
=
5232453952276485270L
;
/**
* The result of the computation.
*/
V
result
;
/**
* The main computation performed by this task.
*/
protected
abstract
V
compute
();
public
final
V
getRawResult
()
{
return
result
;
}
protected
final
void
setRawResult
(
V
value
)
{
result
=
value
;
}
/**
* Implements execution conventions for RecursiveTask.
*/
protected
final
boolean
exec
()
{
result
=
compute
();
return
true
;
}
}
src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java
浏览文件 @
bb129db0
...
...
@@ -61,6 +61,14 @@ import java.util.*;
* causes tasks to be immediately removed from the work queue at
* time of cancellation.
*
* <p>Successive executions of a task scheduled via
* <code>scheduleAtFixedRate</code> or
* <code>scheduleWithFixedDelay</code> do not overlap. While different
* executions may be performed by different threads, the effects of
* prior executions <a
* href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
* those of subsequent ones.
*
* <p>While this class inherits from {@link ThreadPoolExecutor}, a few
* of the inherited tuning methods are not useful for it. In
* particular, because it acts as a fixed-sized pool using
...
...
src/share/classes/java/util/concurrent/ThreadLocalRandom.java
0 → 100644
浏览文件 @
bb129db0
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
/*
* This file is available under and governed by the GNU General Public
* License version 2 only, as published by the Free Software Foundation.
* However, the following notice accompanied the original version of this
* file:
*
* Written by Doug Lea with assistance from members of JCP JSR-166
* Expert Group and released to the public domain, as explained at
* http://creativecommons.org/licenses/publicdomain
*/
package
java.util.concurrent
;
import
java.util.Random
;
/**
* A random number generator isolated to the current thread. Like the
* global {@link java.util.Random} generator used by the {@link
* java.lang.Math} class, a {@code ThreadLocalRandom} is initialized
* with an internally generated seed that may not otherwise be
* modified. When applicable, use of {@code ThreadLocalRandom} rather
* than shared {@code Random} objects in concurrent programs will
* typically encounter much less overhead and contention. Use of
* {@code ThreadLocalRandom} is particularly appropriate when multiple
* tasks (for example, each a {@link ForkJoinTask}) use random numbers
* in parallel in thread pools.
*
* <p>Usages of this class should typically be of the form:
* {@code ThreadLocalRandom.current().nextX(...)} (where
* {@code X} is {@code Int}, {@code Long}, etc).
* When all usages are of this form, it is never possible to
* accidently share a {@code ThreadLocalRandom} across multiple threads.
*
* <p>This class also provides additional commonly used bounded random
* generation methods.
*
* @since 1.7
* @author Doug Lea
*/
public
class
ThreadLocalRandom
extends
Random
{
// same constants as Random, but must be redeclared because private
private
final
static
long
multiplier
=
0x5DEECE66D
L
;
private
final
static
long
addend
=
0xB
L
;
private
final
static
long
mask
=
(
1L
<<
48
)
-
1
;
/**
* The random seed. We can't use super.seed.
*/
private
long
rnd
;
/**
* Initialization flag to permit the first and only allowed call
* to setSeed (inside Random constructor) to succeed. We can't
* allow others since it would cause setting seed in one part of a
* program to unintentionally impact other usages by the thread.
*/
boolean
initialized
;
// Padding to help avoid memory contention among seed updates in
// different TLRs in the common case that they are located near
// each other.
private
long
pad0
,
pad1
,
pad2
,
pad3
,
pad4
,
pad5
,
pad6
,
pad7
;
/**
* The actual ThreadLocal
*/
private
static
final
ThreadLocal
<
ThreadLocalRandom
>
localRandom
=
new
ThreadLocal
<
ThreadLocalRandom
>()
{
protected
ThreadLocalRandom
initialValue
()
{
return
new
ThreadLocalRandom
();
}
};
/**
* Constructor called only by localRandom.initialValue.
* We rely on the fact that the superclass no-arg constructor
* invokes setSeed exactly once to initialize.
*/
ThreadLocalRandom
()
{
super
();
}
/**
* Returns the current thread's {@code ThreadLocalRandom}.
*
* @return the current thread's {@code ThreadLocalRandom}
*/
public
static
ThreadLocalRandom
current
()
{
return
localRandom
.
get
();
}
/**
* Throws {@code UnsupportedOperationException}. Setting seeds in
* this generator is not supported.
*
* @throws UnsupportedOperationException always
*/
public
void
setSeed
(
long
seed
)
{
if
(
initialized
)
throw
new
UnsupportedOperationException
();
initialized
=
true
;
rnd
=
(
seed
^
multiplier
)
&
mask
;
}
protected
int
next
(
int
bits
)
{
rnd
=
(
rnd
*
multiplier
+
addend
)
&
mask
;
return
(
int
)
(
rnd
>>>
(
48
-
bits
));
}
/**
* Returns a pseudorandom, uniformly distributed value between the
* given least value (inclusive) and bound (exclusive).
*
* @param least the least value returned
* @param bound the upper bound (exclusive)
* @throws IllegalArgumentException if least greater than or equal
* to bound
* @return the next value
*/
public
int
nextInt
(
int
least
,
int
bound
)
{
if
(
least
>=
bound
)
throw
new
IllegalArgumentException
();
return
nextInt
(
bound
-
least
)
+
least
;
}
/**
* Returns a pseudorandom, uniformly distributed value
* between 0 (inclusive) and the specified value (exclusive).
*
* @param n the bound on the random number to be returned. Must be
* positive.
* @return the next value
* @throws IllegalArgumentException if n is not positive
*/
public
long
nextLong
(
long
n
)
{
if
(
n
<=
0
)
throw
new
IllegalArgumentException
(
"n must be positive"
);
// Divide n by two until small enough for nextInt. On each
// iteration (at most 31 of them but usually much less),
// randomly choose both whether to include high bit in result
// (offset) and whether to continue with the lower vs upper
// half (which makes a difference only if odd).
long
offset
=
0
;
while
(
n
>=
Integer
.
MAX_VALUE
)
{
int
bits
=
next
(
2
);
long
half
=
n
>>>
1
;
long
nextn
=
((
bits
&
2
)
==
0
)
?
half
:
n
-
half
;
if
((
bits
&
1
)
==
0
)
offset
+=
n
-
nextn
;
n
=
nextn
;
}
return
offset
+
nextInt
((
int
)
n
);
}
/**
* Returns a pseudorandom, uniformly distributed value between the
* given least value (inclusive) and bound (exclusive).
*
* @param least the least value returned
* @param bound the upper bound (exclusive)
* @return the next value
* @throws IllegalArgumentException if least greater than or equal
* to bound
*/
public
long
nextLong
(
long
least
,
long
bound
)
{
if
(
least
>=
bound
)
throw
new
IllegalArgumentException
();
return
nextLong
(
bound
-
least
)
+
least
;
}
/**
* Returns a pseudorandom, uniformly distributed {@code double} value
* between 0 (inclusive) and the specified value (exclusive).
*
* @param n the bound on the random number to be returned. Must be
* positive.
* @return the next value
* @throws IllegalArgumentException if n is not positive
*/
public
double
nextDouble
(
double
n
)
{
if
(
n
<=
0
)
throw
new
IllegalArgumentException
(
"n must be positive"
);
return
nextDouble
()
*
n
;
}
/**
* Returns a pseudorandom, uniformly distributed value between the
* given least value (inclusive) and bound (exclusive).
*
* @param least the least value returned
* @param bound the upper bound (exclusive)
* @return the next value
* @throws IllegalArgumentException if least greater than or equal
* to bound
*/
public
double
nextDouble
(
double
least
,
double
bound
)
{
if
(
least
>=
bound
)
throw
new
IllegalArgumentException
();
return
nextDouble
()
*
(
bound
-
least
)
+
least
;
}
private
static
final
long
serialVersionUID
=
-
5851777807851030925L
;
}
src/share/classes/java/util/concurrent/TransferQueue.java
0 → 100644
浏览文件 @
bb129db0
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
/*
* This file is available under and governed by the GNU General Public
* License version 2 only, as published by the Free Software Foundation.
* However, the following notice accompanied the original version of this
* file:
*
* Written by Doug Lea with assistance from members of JCP JSR-166
* Expert Group and released to the public domain, as explained at
* http://creativecommons.org/licenses/publicdomain
*/
package
java.util.concurrent
;
/**
* A {@link BlockingQueue} in which producers may wait for consumers
* to receive elements. A {@code TransferQueue} may be useful for
* example in message passing applications in which producers
* sometimes (using method {@link #transfer}) await receipt of
* elements by consumers invoking {@code take} or {@code poll}, while
* at other times enqueue elements (via method {@code put}) without
* waiting for receipt.
* {@linkplain #tryTransfer(Object) Non-blocking} and
* {@linkplain #tryTransfer(Object,long,TimeUnit) time-out} versions of
* {@code tryTransfer} are also available.
* A {@code TransferQueue} may also be queried, via {@link
* #hasWaitingConsumer}, whether there are any threads waiting for
* items, which is a converse analogy to a {@code peek} operation.
*
* <p>Like other blocking queues, a {@code TransferQueue} may be
* capacity bounded. If so, an attempted transfer operation may
* initially block waiting for available space, and/or subsequently
* block waiting for reception by a consumer. Note that in a queue
* with zero capacity, such as {@link SynchronousQueue}, {@code put}
* and {@code transfer} are effectively synonymous.
*
* <p>This interface is a member of the
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
* Java Collections Framework</a>.
*
* @since 1.7
* @author Doug Lea
* @param <E> the type of elements held in this collection
*/
public
interface
TransferQueue
<
E
>
extends
BlockingQueue
<
E
>
{
/**
* Transfers the element to a waiting consumer immediately, if possible.
*
* <p>More precisely, transfers the specified element immediately
* if there exists a consumer already waiting to receive it (in
* {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
* otherwise returning {@code false} without enqueuing the element.
*
* @param e the element to transfer
* @return {@code true} if the element was transferred, else
* {@code false}
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this queue
* @throws NullPointerException if the specified element is null
* @throws IllegalArgumentException if some property of the specified
* element prevents it from being added to this queue
*/
boolean
tryTransfer
(
E
e
);
/**
* Transfers the element to a consumer, waiting if necessary to do so.
*
* <p>More precisely, transfers the specified element immediately
* if there exists a consumer already waiting to receive it (in
* {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
* else waits until the element is received by a consumer.
*
* @param e the element to transfer
* @throws InterruptedException if interrupted while waiting,
* in which case the element is not left enqueued
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this queue
* @throws NullPointerException if the specified element is null
* @throws IllegalArgumentException if some property of the specified
* element prevents it from being added to this queue
*/
void
transfer
(
E
e
)
throws
InterruptedException
;
/**
* Transfers the element to a consumer if it is possible to do so
* before the timeout elapses.
*
* <p>More precisely, transfers the specified element immediately
* if there exists a consumer already waiting to receive it (in
* {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
* else waits until the element is received by a consumer,
* returning {@code false} if the specified wait time elapses
* before the element can be transferred.
*
* @param e the element to transfer
* @param timeout how long to wait before giving up, in units of
* {@code unit}
* @param unit a {@code TimeUnit} determining how to interpret the
* {@code timeout} parameter
* @return {@code true} if successful, or {@code false} if
* the specified waiting time elapses before completion,
* in which case the element is not left enqueued
* @throws InterruptedException if interrupted while waiting,
* in which case the element is not left enqueued
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this queue
* @throws NullPointerException if the specified element is null
* @throws IllegalArgumentException if some property of the specified
* element prevents it from being added to this queue
*/
boolean
tryTransfer
(
E
e
,
long
timeout
,
TimeUnit
unit
)
throws
InterruptedException
;
/**
* Returns {@code true} if there is at least one consumer waiting
* to receive an element via {@link #take} or
* timed {@link #poll(long,TimeUnit) poll}.
* The return value represents a momentary state of affairs.
*
* @return {@code true} if there is at least one waiting consumer
*/
boolean
hasWaitingConsumer
();
/**
* Returns an estimate of the number of consumers waiting to
* receive elements via {@link #take} or timed
* {@link #poll(long,TimeUnit) poll}. The return value is an
* approximation of a momentary state of affairs, that may be
* inaccurate if consumers have completed or given up waiting.
* The value may be useful for monitoring and heuristics, but
* not for synchronization control. Implementations of this
* method are likely to be noticeably slower than those for
* {@link #hasWaitingConsumer}.
*
* @return the number of consumers waiting to receive elements
*/
int
getWaitingConsumerCount
();
}
src/share/classes/java/util/concurrent/locks/Condition.java
浏览文件 @
bb129db0
...
...
@@ -170,8 +170,8 @@ import java.util.Date;
* <p>As interruption generally implies cancellation, and checks for
* interruption are often infrequent, an implementation can favor responding
* to an interrupt over normal method return. This is true even if it can be
* shown that the interrupt occurred after another action
may have unblocked
* the thread. An implementation should document this behavior.
* shown that the interrupt occurred after another action
that may have
*
unblocked
the thread. An implementation should document this behavior.
*
* @since 1.5
* @author Doug Lea
...
...
src/share/classes/java/util/concurrent/package-info.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/Collection/BiggernYours.java
浏览文件 @
bb129db0
...
...
@@ -178,10 +178,10 @@ public class BiggernYours {
new
ConcurrentLinkedQueue
()
{
public
int
size
()
{
return
randomize
(
super
.
size
());}});
//
testCollections(
//
new LinkedTransferQueue(),
//
new LinkedTransferQueue() {
//
public int size() {return randomize(super.size());}});
testCollections
(
new
LinkedTransferQueue
(),
new
LinkedTransferQueue
()
{
public
int
size
()
{
return
randomize
(
super
.
size
());}});
testCollections
(
new
LinkedBlockingQueue
(),
...
...
test/java/util/Collection/IteratorAtEnd.java
浏览文件 @
bb129db0
...
...
@@ -49,7 +49,7 @@ public class IteratorAtEnd {
testCollection
(
new
LinkedBlockingQueue
());
testCollection
(
new
ArrayBlockingQueue
(
100
));
testCollection
(
new
ConcurrentLinkedQueue
());
//
testCollection(new LinkedTransferQueue());
testCollection
(
new
LinkedTransferQueue
());
testMap
(
new
HashMap
());
testMap
(
new
Hashtable
());
...
...
test/java/util/Collection/MOAT.java
浏览文件 @
bb129db0
...
...
@@ -76,7 +76,7 @@ public class MOAT {
testCollection
(
new
LinkedBlockingQueue
<
Integer
>(
20
));
testCollection
(
new
LinkedBlockingDeque
<
Integer
>(
20
));
testCollection
(
new
ConcurrentLinkedQueue
<
Integer
>());
//
testCollection(new LinkedTransferQueue<Integer>());
testCollection
(
new
LinkedTransferQueue
<
Integer
>());
testCollection
(
new
ConcurrentSkipListSet
<
Integer
>());
testCollection
(
Arrays
.
asList
(
new
Integer
(
42
)));
testCollection
(
Arrays
.
asList
(
1
,
2
,
3
));
...
...
test/java/util/Collections/CheckedNull.java
浏览文件 @
bb129db0
...
...
@@ -52,7 +52,7 @@ public class CheckedNull {
testMap
(
Collections
.
checkedMap
(
new
HashMap
<
String
,
String
>(),
String
.
class
,
String
.
class
));
;
String
.
class
,
String
.
class
));
}
ClassCastException
cce
(
F
f
)
{
...
...
test/java/util/Collections/RacingCollections.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/PriorityQueue/RemoveContains.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/BlockingQueue/CancelledProducerConsumerLoops.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/BlockingQueue/LastElement.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/BlockingQueue/MultipleProducersSingleConsumerLoops.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/BlockingQueue/OfferDrainToLoops.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/BlockingQueue/PollMemoryLeak.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/BlockingQueue/ProducerConsumerLoops.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/BlockingQueue/SingleProducerMultipleConsumerLoops.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/ConcurrentQueues/ConcurrentQueueLoops.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/ConcurrentQueues/GCRetention.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/ConcurrentQueues/IteratorWeakConsistency.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/ConcurrentQueues/OfferRemoveLoops.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/ConcurrentQueues/RemovePollRace.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/Phaser/Arrive.java
0 → 100644
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/Phaser/Basic.java
0 → 100644
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/ScheduledThreadPoolExecutor/DelayOverflow.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/forkjoin/Integrate.java
0 → 100644
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/forkjoin/NQueensCS.java
0 → 100644
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/locks/ReentrantLock/CancelledLockLoops.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
test/java/util/concurrent/locks/ReentrantReadWriteLock/RWMap.java
浏览文件 @
bb129db0
此差异已折叠。
点击以展开。
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录