为什么Java并发处理不适用于新实例化的对象，而它适用于同一类的反序列化对象？

Question

我正在使用java.util.concurrent.ExecutorService对所有可用处理资源执行并发计算。在下面的代码中，MyProcessor类的实例在其performParallelProcessing方法中创建了多个ProcessingExecutor类实例，并将它们提交给ExecutorService实例，以期获得相应的回调。

处理发生在ProcessingExecutor类的performProcessing方法中。我用于处理的数据是类ComputationData的对象实例。它们可以从文件系统中检索（如果序列化数据存在），或者可以初始化为新实例。

这里的问题是：

在这种情况下，如果ComputationData对象实例从文件系统反序列化，并行处理执行，因为我希望它做的事。它在所有处理核心上并行运行，占用了100％的处理资源。

在ComputationData对象实例被新初始化的情况下，并发处理不按照我的预期执行。它的运行就像是单线程执行，占用了大约15％的处理资源。

正如我所猜，我的新初始化的ComputationData对象实例有问题。但是我不知道他们有什么问题，以及为什么并发不适用于他们，而他们的序列化 - >反序列化版本。任何提示或想法将不胜感激。

public class MyProcessor { 
    private boolean processingFinished = false; 

    public void performParallelProcessing(){ 
     int count = 0; 
     boolean continueProcessing = true; 

     int nrOfProcessors = Runtime.getRuntime().availableProcessors(); 
     ExecutorService es = Executors.newFixedThreadPool(nrOfProcessors); 

     while (continueProcessing){ 
      ProcessingExecutor task = new ProcessingExecutor(count); 
      task.setCaller(this); 
      es.submit(task); 
      count++; 

      if (!processingFinished){ 
       try{ 
        Thread.sleep(50); 
       } 
       catch(SecurityException | InterruptedException e){ 
        //Exception handling 
       } 
      } 
      else{ 
       continueProcessing = false; 
      } 
     } 
    } 

    public void callBack(ProcessingResult result) { 
     if(result.allDataProcessed()){ 
      this.processingFinished = true; 
     } 
    } 
} 

public class ProcessingExecutor implements Callable { 
    private MyProcessor processor; 
    private int count; 

    public ProcessingExecutor(int count){ 
     this.count = count; 
    } 

    public Object call() { 
     ProcessingResult result = null; 
     try { 
      result = performProcessing(); 
     } 
     catch (SecurityException e) { 
      //Exception handling 
     } 

     processor.callBack(result);  
     return null; 
    } 

    public void setCaller(MyProcessor processor) { 
     this.processor = processor; 
    } 

    public MyProcessor getCaller() { 
     return this.processor; 
    } 

    private ProcessingResult performProcessing(){ 
     ComputationData data = null; 

     if(serializedDataExist()){ 
      data = getSerializedData(count); 
     } 
     else{ 
      data = initializeNewData(count); 
     } 

     ProcessingResult result = new ProcessingResult(data, count); 
     return result; 
    } 

    private ComputationData getSerializedData(int count){ 
     ComputationData data = null; 
     // code to retrieve a ComputationData object from the file system 
     // based on 'count' value. 
     return data; 
    } 

    private ComputationData initializeNewData(int count){ 
     ComputationData data = null; 
     // code to initialize a new instance of ComputationData class 
     // based on 'count' value. 
     return data; 
    } 

    private boolean serializedDataExist(){ 
     boolean dataFound = false; 
     // code to verify whether serialized ComputationData objects are 
     // present on the file system. 
     return dataFound; 
    } 
} 

Answer 1

为什么你需要Thread.sleep(50)？这是使并发执行成为顺序执行的一种方式，特别是如果每​​次计算都是< = 50毫秒。我的猜测是反序列化时间+计算时间超过50毫秒，这就是为什么在反序列化对象场景中，您有更多的CPU活动，因为您在执行程序线程中同时有效地执行多个任务。你应该尝试没有Thread.sleep(50)或至少有一个小得多的超时。