從Java 8

Question

數學庫小馬（1.2版）編譯老圖書館併發的失敗依賴於庫EDU.oswego.cs.dl.util.concurrent（gee.cs.oswego.edu/dl/類/ EDU /奧斯威戈/ CS/DL/util的/並行/ intro.html）。編譯併發（版本1.3.4）在java版本7或以前版本上工作。然而編譯在java 8（javac版本1.8）上失敗。編譯器選項-source 1.4 -target 1.4不能解決問題。

原因是，java 8在接口java.util.Map中引入了一個新的方法「remove」：default boolean remove(Object key, Object value)。 這個新方法與實現java.util.Map的庫類ConcurrentHashMap.java中的「remove」方法衝突：protected Object remove(Object key, Object value)。

一旦確定問題的原因，我可以通過在庫類ConcurrentHashMap.java中重命名方法來解決問題。這是可以接受的，因爲庫方法只受保護（不公開）。

是否有其他可能性來確保Java 8的兼容性？

• 編譯器選項？
• 註解（「@ForceOverride」）？

Answer 1

沒有編譯器選項和註釋將忽略衝突的方法簽名。

如果你（或者，在這種情況下，小馬）不使用新remove方法，只是編譯Java 7中的Java下8下編譯它不會給你任何好處。

但在這種情況下，我更喜歡你的解決方案。

Answer 2

考慮到這個類是JRE類的基礎，也稱爲ConcurrentHashMap，這裏沒有名稱衝突，因爲該方法具有完全意圖的語義。衝突發生，因爲該方法是protected，這個決定很久以前就已經修改過了。即當您查看該課程的Java 5版本時，您會發現它已經有the method remove(Object, Object)，它是public。它也要求ConcurrentMap interface，因此必須是public。

因此，最簡單的修復方法不是重命名它，而是將修改器更改爲public並調整返回類型。

---

但你是正確的in your comment，從長遠來看，最好的解決方案是遷移到該類as recommend by the author himself的JRE版本：

注：在J2SE 5.0的發佈，這個包進入維修模式：只有必要的更正將被釋放。 J2SE5包java.util.concurrent包含了此包中主要組件的改進，更高效，標準化的版本。請計劃轉換您的應用程序以使用它們。

而這是比十年前更多... EDU.oswego.cs.dl.util.concurrent到的java.util.concurrent類

Answer 3

遷移小馬。正如Holger的回答所引用的，圖書館作者建議這樣做。

Gentoo給小馬1.2.0源代碼patch：

--- 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(); 
-} 
}