Remove our fork of forkjoin. Java 8 bundles it.

Provide deprecated compatibility stubs for the types and static members,
which forward as follows:

```
scala.concurrent.forkjoin.ForkJoinPool         => java.util.concurrent.ForkJoinPool
scala.concurrent.forkjoin.ForkJoinTask         => java.util.concurrent.ForkJoinTask
scala.concurrent.forkjoin.ForkJoinWorkerThread => java.util.concurrent.ForkJoinWorkerThread
scala.concurrent.forkjoin.LinkedTransferQueue  => java.util.concurrent.LinkedTransferQueue
scala.concurrent.forkjoin.RecursiveAction      => java.util.concurrent.RecursiveAction
scala.concurrent.forkjoin.RecursiveTask        => java.util.concurrent.RecursiveTask
scala.concurrent.forkjoin.ThreadLocalRandom    => java.util.concurrent.ThreadLocalRandom
```

To prepare for Java 9, the Scala library does not itself use `sun.misc.Unsafe`.
However, for now, it provide a convenience accessor for it
via `scala.concurrent.util.Unsafe`. This (deprecated) class will
be removed as soon as the eco-system drops its use
(akka-actor, I'm looking at you).

1 files changed, 0 insertions, 28 deletions

diff --git a/src/forkjoin/scala/concurrent/forkjoin/package-info.java b/src/forkjoin/scala/concurrent/forkjoin/package-info.java
deleted file mode 100644
index 3561b9b44a..0000000000
--- a/src/forkjoin/scala/concurrent/forkjoin/package-info.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * 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/publicdomain/zero/1.0/
- */
-
-
-/**
- * Preview versions of classes targeted for Java 7.  Includes a
- * fine-grained parallel computation framework: ForkJoinTasks and
- * their related support classes provide a very efficient basis for
- * obtaining platform-independent parallel speed-ups of
- * computation-intensive operations.  They are not a full substitute
- * for the kinds of arbitrary processing supported by Executors or
- * Threads. However, when applicable, they typically provide
- * significantly greater performance on multiprocessor platforms.
- *
- * <p>Candidates for fork/join processing mainly include those that
- * can be expressed using parallel divide-and-conquer techniques: To
- * solve a problem, break it in two (or more) parts, and then solve
- * those parts in parallel, continuing on in this way until the
- * problem is too small to be broken up, so is solved directly.  The
- * underlying <em>work-stealing</em> framework makes subtasks
- * available to other threads (normally one per CPU), that help
- * complete the tasks.  In general, the most efficient ForkJoinTasks
- * are those that directly implement this algorithmic design pattern.
- */
-package scala.concurrent.forkjoin;