Java线程操作、并行编程

我正在学习一门关于java编程的在线课程，遇到了这个问题，我正在研究使用线程的并行编程

我将制作一个“四核”版本的程序，通过将总和的范围划分为四个相等的部分来计算pi，并使用四个线程

我试着把它分成4个不同的线程，并开始和加入每个线程

public class quadCorePi extends Thread {

public static void main(String[] args) throws Exception {

          long startTime = System.currentTimeMillis();

          quadCorePi thread1 = new quadCorePi();
          thread1.begin = 0 ;
          thread1.end = numSteps / 4 ;

          quadCorePi thread2 = new quadCorePi();
          thread2.begin = 1 ;
          thread2.end = numSteps / 4 ;

          quadCorePi thread3 = new quadCorePi();
          thread3.begin = 2 ;
          thread3.end = numSteps / 4 ;

          quadCorePi thread4 = new quadCorePi();
          thread4.begin = numSteps / 4 ;
          thread4.end = numSteps ;



          thread1.start();
          thread2.start();
          thread3.start();
          thread4.start();

          thread1.join();
          thread2.join();
          thread3.join();
          thread4.join();

          long endTime = System.currentTimeMillis();

          double pi = step * (thread1.sum + thread2.sum + thread3.sum + thread4.sum);


          System.out.println("Value of pi: " + pi);

          System.out.println("Calculated in " +
                             (endTime - startTime) + " milliseconds");
      }

但是它给了我一个错误的pi值，一个解释将对如何分割线程的工作非常有帮助

这是给出的示例代码：

public class ParallelPi extends Thread {

  public static void main(String[] args) throws Exception {

      long startTime = System.currentTimeMillis();

      ParallelPi thread1 = new ParallelPi();
      thread1.begin = 0 ;
      thread1.end = numSteps / 2 ;

      ParallelPi thread2 = new ParallelPi();
      thread2.begin = numSteps / 2 ;
      thread2.end = numSteps ;

      thread1.start();
      thread2.start();

      thread1.join();
      thread2.join();

      long endTime = System.currentTimeMillis();

      double pi = step * (thread1.sum + thread2.sum) ;

      System.out.println("Value of pi: " + pi);

      System.out.println("Calculated in " +
                         (endTime - startTime) + " milliseconds");
  }

  static int numSteps = 10000000;

  static double step = 1.0 / (double) numSteps;

  double sum ;  
  int begin, end ;

  public void run() {

      sum = 0.0 ;

      for(int i = begin ; i < end ; i++){
          double x = (i + 0.5) * step ;
          sum += 4.0 / (1.0 + x * x);
      }
  }
  }

公共类ParallelPi扩展线程{
公共静态void main（字符串[]args）引发异常{
long startTime=System.currentTimeMillis（）；
ParallelPi thread1=新的ParallelPi（）；
thread1.begin=0；
thread1.end=numSteps/2；
ParallelPi thread2=新的ParallelPi（）；
thread2.begin=numSteps/2；
thread2.end=numSteps；
thread1.start（）；
thread2.start（）；
thread1.join（）；
螺纹2.连接（）；
long-endTime=System.currentTimeMillis（）；
双pi=步骤*（thread1.sum+thread2.sum）；
System.out.println（“pi的值：+pi”）；
System.out.println（“计算单位”+
（endTime-startTime）+“毫秒”）；
}
静态int numSteps=10000000；
静态双步=1.0/（双）微步；
双和；
int开始，结束；
公开募捐{
总和=0.0；
for（int i=begin；i

您确定计算器的限值正常吗？难道不是：

thread2.begin = numSteps / 4 + 1 ;
thread2.end = numSteps / 2;

---

以此类推，3和4的限制是不正确的。以下是更正后的代码：

public class QuadCorePi extends Thread {

    public static void main(String[] args) throws Exception {

        long startTime = System.currentTimeMillis();

        QuadCorePi thread1 = new QuadCorePi();
        thread1.begin = 0 ;
        thread1.end = numSteps / 4 ;

        QuadCorePi thread2 = new QuadCorePi();
        thread2.begin = numSteps / 4 ;
        thread2.end =  numSteps  / 2 ;

        QuadCorePi thread3 = new QuadCorePi();
        thread3.begin = numSteps / 2 ;
        thread3.end = 3 * numSteps / 4 ;

        QuadCorePi thread4 = new QuadCorePi();
        thread4.begin = 3 * numSteps / 4 ;
        thread4.end = numSteps ;

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();

        thread1.join();
        thread2.join();
        thread3.join();
        thread4.join();

        long endTime = System.currentTimeMillis();

        double pi = step * (thread1.sum + thread2.sum + thread3.sum + thread4.sum) ;

        System.out.println("Value of pi: " + pi);

        System.out.println("Calculated in " +
                (endTime - startTime) + " milliseconds");
    }

    static int numSteps = 10000000;

    static double step = 1.0 / (double) numSteps;

    double sum ;
    int begin, end ;

    public void run() {

        sum = 0.0 ;

        for(int i = begin ; i < end ; i++){
            double x = (i + 0.5) * step ;
            sum += 4.0 / (1.0 + x * x);
        }
    }
}

公共类QuadCorePi扩展线程{
公共静态void main（字符串[]args）引发异常{
long startTime=System.currentTimeMillis（）；
QuadCorePi thread1=新的QuadCorePi（）；
thread1.begin=0；
thread1.end=numSteps/4；
QuadCorePi thread2=新的QuadCorePi（）；
thread2.begin=numSteps/4；
thread2.end=numSteps/2；
QuadCorePi thread3=新的QuadCorePi（）；
thread3.begin=numSteps/2；
thread3.end=3*numSteps/4；
QuadCorePi thread4=新的QuadCorePi（）；
thread4.begin=3*numSteps/4；
thread4.end=numSteps；
thread1.start（）；
thread2.start（）；
thread3.start（）；
thread4.start（）；
thread1.join（）；
螺纹2.连接（）；
螺纹3.连接（）；
螺纹4.连接（）；
long-endTime=System.currentTimeMillis（）；
双pi=步骤*（thread1.sum+thread2.sum+thread3.sum+thread4.sum）；
System.out.println（“pi的值：+pi”）；
System.out.println（“计算单位”+
（endTime-startTime）+“毫秒”）；
}
静态int numSteps=10000000；
静态双步=1.0/（双）微步；
双和；
int开始，结束；
公开募捐{
总和=0.0；
for（int i=begin；i

一个改进是使用适当的Java并发库-在这种情况下，代码的外观如下：

public class ParallelPi implements Callable<Double> {
    private static final ExecutorService executorService = 
            Executors.newFixedThreadPool(4);
    private static final int numSteps = 10000000;
    private static final double step = 1.0 / (double) numSteps;

    private final int begin, end;

    public ParallelPi(int begin, int end) {
        this.begin = begin;
        this.end = end;
    }

    public static void main(String[] args) throws Exception {
        long startTime = System.currentTimeMillis();

        List<Future<Double>> results = executorService.invokeAll(Arrays.asList(
                new ParallelPi(0, numSteps / 4), 
                new ParallelPi(numSteps / 4, numSteps / 2),
                new ParallelPi(numSteps / 2, 3 * numSteps / 4),
                new ParallelPi(3 * numSteps / 4, numSteps)));

        double pi = 0;
        for(Future<Double> result: results) {
            pi += result.get();
        }
        pi *= step;

        long endTime = System.currentTimeMillis();

        System.out.println("Value of pi: " + pi);
        System.out.println("Calculated in " + 
                (endTime - startTime) + " milliseconds");
    }

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

        for (int i = begin; i < end; i++) {
            double x = (i + 0.5) * step;
            sum += 4.0 / (1.0 + x * x);
        }
        return sum;
    }
}

公共类ParallelPi实现了可调用{
专用静态最终执行器服务执行器服务=
执行者。newFixedThreadPool（4）；
私有静态最终整数numSteps=10000000；
专用静态最终双步=1.0/（双）微步；
私人最终整数开始，结束；
公共并行PI（整数开始，整数结束）{
this.begin=开始；
this.end=end；
}
公共静态void main（字符串[]args）引发异常{
long startTime=System.currentTimeMillis（）；
列表结果=executorService.invokeAll（Arrays.asList(
新的并行PI（0，numSteps/4），
新的并行PI（numSteps/4，numSteps/2），
新的并行PI（numSteps/2，3*numSteps/4），
新的并行PI（3*numSteps/4，numSteps））；
双pi=0；
用于（未来结果：结果）{
pi+=result.get（）；
}
pi*=阶跃；
long-endTime=System.currentTimeMillis（）；
System.out.println（“pi的值：+pi”）；
System.out.println（“以“+
（endTime-startTime）+“毫秒”）；
}
@凌驾
public Double call（）引发异常{
双和=0.0；
for（int i=begin；i

您确定您的计算正确吗；意思：当您调用代码时，上面没有任何多线程吗？

公共类quadCorePi扩展了线程

，它针对之前给出的一个示例运行。首先，使用java.util.concurrent包，而不是执行低级线程处理-这要简单得多。不太简单。限制分为4个范围。谢谢，是的，我的限制是错误的，谢谢关于类名的提示。