Scala中的Akka actor教程到Java中的多线程

我试图将Akka入门教程从Scala转换为Java，并用线程替换参与者

教程可以在这里找到

原始Pi.scala文件可以从Typesafe giter8模板库中检出

g8 typesafehub/akka第一教程scala

我想知道我所做的是否正确

这是我的Pi.java

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class Pi {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Listener listener = new Listener();

        //calculate(nrOfWorkers = 10, nrOfElements = 10000, nrOfMessages = 10000)
        Master master = new Master(4, 1000, 1000, listener);
        master.calculate();
    }
}

class Worker implements Callable<Double> {

    private int start;
    private int nrOfElements;

    public Worker(int start, int nrOfElements) {
        this.start = start;
        this.nrOfElements = nrOfElements;
    }

    @Override
    public Double call() throws Exception {
        double acc = 0.0;

        for(int i = start; i < start + nrOfElements; i++) {
            acc += 4.0 * (1 - (i % 2) * 2) / (2 * i + 1);
        }
        return acc;
    }
}

class Listener {

    public void PiApproximation(double pi, long duration) {
        System.out.println(String.format("\n\tPi approximation: \t\t%s\n\tCalculation time: \t%s", pi, duration));
    }

}

class Master {

    private double pi = 0.0;
    private int nrOfResults = 0;
    private final long start = java.lang.System.currentTimeMillis();

    private int nrOfWorkers;
    private int nrOfMessages;
    private int nrOfElements;
    private Listener listener;

    private ExecutorService executor;

    public Master(int nrOfWorkers, 
                  int nrOfMessages, 
                  int nrOfElements, 
                  Listener listener) {

        this.nrOfWorkers = nrOfWorkers;
        this.nrOfMessages = nrOfMessages;
        this.nrOfElements = nrOfElements;
        this.listener = listener;

        //Round robin scheduling is not enforced here as in akka.
        executor = Executors.newFixedThreadPool(nrOfWorkers);
    }

    public void calculate() {
        List<Future<Double>> list = new ArrayList<Future<Double>>();

        for (int i = 0; i < nrOfMessages; i++) {
              Callable<Double> worker = new Worker(i * nrOfElements, nrOfElements);
              Future<Double> submit = executor.submit(worker);
              list.add(submit);
        }

        for (Future<Double> future : list) {
            try {
                pi += future.get();
            } 
            catch (InterruptedException e) { e.printStackTrace(); } 
            catch (ExecutionException e) { e.printStackTrace(); }
        }
        //send results to listener
        listener.PiApproximation(pi, java.lang.System.currentTimeMillis() - start);

        executor.shutdown();
    }
}

import java.util.ArrayList；
导入java.util.List；
导入java.util.concurrent.*；
公共类Pi{
/**
*@param args
*/
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
Listener=新的Listener（）；
//计算（nrOfWorkers=10，nrOfElements=10000，nrOfMessages=10000）
Master-Master=新Master（4,1000,1000，侦听器）；
master.calculate（）；
}
}
类工作者实现了可调用的{
私人int启动；
私有元素；
公共工作者（int start、int nrOfElements）{
this.start=start；
this.nrofements=nrofements；
}
@凌驾
public Double call（）引发异常{
双acc=0.0；
对于（int i=start；i

本教程的java版本也在线提供：

然而，它不是在使用线程，而是在java中使用参与者。

---

为什么要使用参与者的线程instad？

本教程的java版本也在线提供：

然而，它不是在使用线程，而是在java中使用参与者。 为什么要使用演员的线程