自Java 8以来旧库并发编译失败

数学库colt（版本1.2）依赖于库EDU.oswego.cs.dl.util.concurrent（gee.cs.oswego.EDU/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html）。编译并发（1.3.4版）适用于java 7版或以前的版本。但是在java 8上编译失败（javac 1.8版）。编译器选项

-源1.4-目标1.4

无法解决此问题

原因是java 8在接口java.util.Map中引入了一个新方法“remove:”。 此新方法与库类ConcurrentHashMap.java中的方法“remove”冲突，后者实现了java.util.Map:

一旦确定了问题的原因，我就可以通过重命名库类ConcurrentHashMap.java中的方法来解决问题。这是可以接受的，因为库方法仅受保护（而不是公共的）

是否有其他可能性来确保Java8的兼容性

• 编译器选项
• 注释（“@ForceOverride”）

---

没有编译器选项或注释会忽略冲突的方法签名
如果您（或者在本例中是colt）没有使用新的

remove

方法，只需在Java7下编译它即可。在Java8下编译它不会给您带来任何好处

---

但实际上我更喜欢这种情况下的解决方案。
考虑到这个类是JRE类（也称为

ConcurrentHashMap

）的基础，这里没有名称冲突，因为该方法完全具有预期的语义。发生冲突，因为该方法受保护，这是一个很久以前就已经修改过的决定。也就是说，当您查看该类的Java5版本时，您将看到它已经有了，并且它是

public

。它也是用户要求的，因此必须是

公共的

因此，最简单的修复方法不是重命名它，而是将修饰符更改为

public

，并调整返回类型

---

但您是对的，从长远来看，最好的解决方案是迁移到该类的JRE版本：
注：J2SE 5.0发布后，该软件包进入维护模式：仅发布基本更正。J2SE5包java.util.concurrent包含此包中主要组件的改进、更高效、标准化版本。请计划转换您的应用程序以使用它们
这是十多年前的事了…
将colt从EDU.oswego.cs.dl.util.concurrent迁移到java.util.concurrent类。正如霍尔格的回答中所引用的那样，图书馆兼职作者建议这样做
Gentoo为colt 1.2.0源代码提供了一个示例：

--- src/cern/colt/matrix/linalg/SmpBlas.java.orig   2015-10-07 22:23:44.969486000 +0000
+++ src/cern/colt/matrix/linalg/SmpBlas.java    2015-10-07 22:29:15.475486000 +0000
@@ -10,7 +10,8 @@

 import cern.colt.matrix.DoubleMatrix1D;
 import cern.colt.matrix.DoubleMatrix2D;
-import EDU.oswego.cs.dl.util.concurrent.FJTask;
+
+import java.util.concurrent.ForkJoinTask;
 /**
 Parallel implementation of the Basic Linear Algebra System for symmetric multi processing boxes.
 Currently only a few algorithms are parallelised; the others are fully functional, but run in sequential mode.
@@ -198,7 +199,7 @@

    // set up concurrent tasks
    int span = width/noOfTasks;
-   final FJTask[] subTasks = new FJTask[noOfTasks];
+   final ForkJoinTask[] subTasks = new ForkJoinTask[noOfTasks];
    for (int i=0; i<noOfTasks; i++) {
        final int offset = i*span;
        if (i==noOfTasks-1) span = width - span*i; // last span may be a bit larger
@@ -217,24 +218,30 @@
            CC = C.viewPart(offset,0,span,p);
        }

-       subTasks[i] = new FJTask() { 
+       subTasks[i] = new ForkJoinTask() { 
            public void run() { 
                seqBlas.dgemm(transposeA,transposeB,alpha,AA,BB,beta,CC); 
                //System.out.println("Hello "+offset); 
            }
+
+      public boolean exec() { return true; }
+      public void setRawResult(Object o) {}
+      public Object getRawResult() {return null;}
        };
    }

    // run tasks and wait for completion
-   try { 
-       this.smp.taskGroup.invoke(
-           new FJTask() {
-               public void run() { 
-                   coInvoke(subTasks); 
-               }
-           }
-       );
-   } catch (InterruptedException exc) {}
+  this.smp.taskGroup.invoke(
+          new ForkJoinTask() {
+              public void run() {  
+                  invokeAll(subTasks); 
+              }
+
+              public boolean exec() { return true; }
+              public void setRawResult(Object o) {}
+              public Object getRawResult() {return null;}
+          }
+          );
 }
 public void dgemv(final boolean transposeA, final double alpha, DoubleMatrix2D A, final DoubleMatrix1D x, final double beta, DoubleMatrix1D y) {
    /*
@@ -271,7 +278,7 @@

    // set up concurrent tasks
    int span = width/noOfTasks;
-   final FJTask[] subTasks = new FJTask[noOfTasks];
+   final ForkJoinTask[] subTasks = new ForkJoinTask[noOfTasks];
    for (int i=0; i<noOfTasks; i++) {
        final int offset = i*span;
        if (i==noOfTasks-1) span = width - span*i; // last span may be a bit larger
@@ -280,24 +287,30 @@
        final DoubleMatrix2D AA = A.viewPart(offset,0,span,n);
        final DoubleMatrix1D yy = y.viewPart(offset,span);

-       subTasks[i] = new FJTask() { 
+       subTasks[i] = new ForkJoinTask() { 
            public void run() { 
                seqBlas.dgemv(transposeA,alpha,AA,x,beta,yy); 
                //System.out.println("Hello "+offset); 
            }
+
+      public boolean exec() { return true; }
+      public void setRawResult(Object o) {}
+      public Object getRawResult() {return null;}
        };
    }

    // run tasks and wait for completion
-   try { 
-       this.smp.taskGroup.invoke(
-           new FJTask() {
-               public void run() { 
-                   coInvoke(subTasks); 
-               }
-           }
-       );
-   } catch (InterruptedException exc) {}
+  this.smp.taskGroup.invoke(
+          new ForkJoinTask() {
+              public void run() {  
+                  invokeAll(subTasks); 
+              }
+
+              public boolean exec() { return true; }
+              public void setRawResult(Object o) {}
+              public Object getRawResult() {return null;}
+          }
+          );
 }
 public void dger(double alpha, DoubleMatrix1D x, DoubleMatrix1D y, DoubleMatrix2D A) {
    seqBlas.dger(alpha,x,y,A);
@@ -369,9 +382,6 @@
 /**
  * Prints various snapshot statistics to System.out; Simply delegates to {@link EDU.oswego.cs.dl.util.concurrent.FJTaskRunnerGroup#stats}.
  */
-public void stats() {
-   if (this.smp!=null) this.smp.stats();
-}
 private double xsum(DoubleMatrix2D A) {
    double[] sums = run(A,true,
        new Matrix2DMatrix2DFunction() {
--- src/cern/colt/matrix/linalg/Smp.java.orig   2015-10-07 21:08:19.443486000 +0000
+++ src/cern/colt/matrix/linalg/Smp.java    2015-10-07 22:28:24.722486000 +0000
@@ -9,12 +9,13 @@
 package cern.colt.matrix.linalg;

 import cern.colt.matrix.DoubleMatrix2D;
-import EDU.oswego.cs.dl.util.concurrent.FJTask;
-import EDU.oswego.cs.dl.util.concurrent.FJTaskRunnerGroup;
+import java.util.concurrent.ForkJoinTask;
+import java.util.concurrent.ForkJoinPool;
+
 /*
 */
 class Smp {
-   protected FJTaskRunnerGroup taskGroup; // a very efficient and light weight thread pool
+   protected ForkJoinPool taskGroup; // a very efficient and light weight thread pool

    protected int maxThreads;   
 /**
@@ -24,41 +25,39 @@
    maxThreads = Math.max(1,maxThreads);
    this.maxThreads = maxThreads;
    if (maxThreads>1) {
-       this.taskGroup = new FJTaskRunnerGroup(maxThreads);
+       this.taskGroup = new ForkJoinPool(maxThreads);
    }
    else { // avoid parallel overhead
        this.taskGroup = null;
    }
 }
-/**
- * Clean up deamon threads, if necessary.
- */
-public void finalize() {
-   if (this.taskGroup!=null) this.taskGroup.interruptAll();
-}
 protected void run(final DoubleMatrix2D[] blocksA, final DoubleMatrix2D[] blocksB, final double[] results, final Matrix2DMatrix2DFunction function) {
-   final FJTask[] subTasks = new FJTask[blocksA.length];
+   final ForkJoinTask[] subTasks = new ForkJoinTask[blocksA.length];
    for (int i=0; i<blocksA.length; i++) {
        final int k = i;
-       subTasks[i] = new FJTask() { 
+       subTasks[i] = new ForkJoinTask() { 
            public void run() {
                double result = function.apply(blocksA[k],blocksB != null ? blocksB[k] : null);
                if (results!=null) results[k] = result; 
                //System.out.print("."); 
            }
+      public boolean exec() { return true; }
+      public void setRawResult(Object o) {}
+      public Object getRawResult() {return null;}
        };
    }

    // run tasks and wait for completion
-   try { 
-       this.taskGroup.invoke(
-           new FJTask() {
-               public void run() { 
-                   coInvoke(subTasks); 
-               }
-           }
-       );
-   } catch (InterruptedException exc) {}
+  this.taskGroup.invoke(
+          new ForkJoinTask() {
+              public void run() {  
+                  invokeAll(subTasks); 
+              }
+              public boolean exec() { return true; }
+              public void setRawResult(Object o) {}
+              public Object getRawResult() {return null;}
+          }
+          );
 }
 protected DoubleMatrix2D[] splitBlockedNN(DoubleMatrix2D A, int threshold, long flops) {
    /*
@@ -186,10 +185,4 @@
    }
    return blocks;
 }
-/**
- * Prints various snapshot statistics to System.out; Simply delegates to {@link EDU.oswego.cs.dl.util.concurrent.FJTaskRunnerGroup#stats}.
- */
-public void stats() {
-   if (this.taskGroup!=null) this.taskGroup.stats();
-}
 }

——src/cern/colt/matrix/linalg/SmpBlas.java.orig 2015-10-07 22:23:44.969486000+0000
+++src/cern/colt/matrix/linalg/SmpBlas.java 2015-10-07 22:29:15.475486000+0000
@@ -10,7 +10,8 @@
导入cern.colt.matrix.DoubleMatrix1D；
导入cern.colt.matrix.DoubleMatrix2D；
-导入EDU.oswego.cs.dl.util.concurrent.FJTask；
+
+导入java.util.concurrent.ForkJoinTask；
/**
对称多处理盒基本线性代数系统的并行实现。
目前只有少数算法是并行的；其他系统功能齐全，但以顺序模式运行。
@@ -198,7 +199,7 @@
//设置并发任务
int span=宽度/宽度；
-最终FJTask[]子任务=新FJTask[Nooftask]；
+最终ForkJoinTask[]子任务=新的ForkJoinTask[noOfTasks]；
对于（int i=0；iIt），其他人似乎遇到了相同的问题：。我不确定这是否是正确的方法，但我们解决了类似的问题：这将涉及更改colt库中的一些代码。从长远来看，可能确实值得将原始并发迁移到java.util.concurrent（我认为在我的例子中，由backport提供的java<6的兼容性不再是必要的）。我只是担心这不是直接的…是的，这是我自己做的。然后我被报告（由opensuse构建服务）这个并发代码没有在Fedora23上编译，可能java 7不可用。但是如果有人运行jar（在java 7上编译），会发生什么呢在java 8上？我想它可能会失败，因为没有java 7 runtime.Ah。那么，似乎你做得最好。将修饰符更改为public并调整返回类型是考虑过的，但它涉及的更改不仅仅是重命名方法（因为使用了返回的对象）。但实际上这个解决方案与“重命名”非常类似这是我第一次遇到java不兼容问题（由于映射接口的更改/增强）。我希望有一个仅使用编译器选项的解决方案。不幸的是，没有。为了与早期版本完全兼容，您需要指定
-target
选项和JRE库的较旧版本。当您在没有适当（较旧）选项的情况下指定
-target
选项时，最新的编译器将向您发出警告类库…