在java中使用多线程计算从1到100000000的数字之和

Question

我试图用Java中的多线程编写一个程序，打印从1到100000000的数字之和。其想法是，第一个线程将计算从1到25000000的数字之和；第二个线程将计算数字的总和从2500001到50000000等等。主线程必须在收集结果。我尝试扩展Thread类。

class Thread1 extends Thread{

public void run() {
//int i=num;
int i;
for(i=1;i<25000001;i++)
i+=i;
System.out.println("Thread 1: the sum is: "+i);

mainThread m=new mainThread();
m.guther(i);
}
}
class Thread2 extends Thread{

public void run() {
//int i=num;
int i;
for(i=25000001;i<50000001;i++)
i+=i;
System.out.println("Thread 2: the sum is: "+i);

mainThread m=new mainThread();
m.guther(i);
}
}

class Thread3 extends Thread{

public void run() {
//int i=num;
int i;
for(i=50000001;i<75000001;i++)
i+=i;
System.out.println("Thread 3: the sum is: "+i);

mainThread m=new mainThread();
m.guther(i);
}
}
class Thread4 extends Thread{

public void run() {
//int i=num;
int i;
for(i=75000001;i<100000001;i++)
i+=i;
System.out.println("Thread 4: the sum is: "+i);

mainThread m=new mainThread();
m.guther(i);
}
}
class mainThread{


void guther(int total) {
for(int i=1;i<=1;i++)
total+=total;
System.out.println("mainThread : the sum is: "+total);

}
/*public void run() {

mainThread m=new mainThread();
System.out.println(Thread.currentThread().getId()+"the total is: ");
}*/

}
public class startThread {
public static void main(String[] args) {
//thread 1
Thread1 t1=new Thread1();
t1.start();
//t1.run(1);

//thread 2
Thread2 t2=new Thread2();
t2.start();
//t2.run(25000001);

//thread 3
Thread3 t3=new Thread3();
t3.start();
//t3.run(50000001);

//thread 4
Thread4 t4=new Thread4();
t4.start();
//t4.run(75000001);

//int total=t1.run(1)+t2.run(25000001)+t3.run(50000001)+t4.run(75000001);
//System.out.println("the total is: "+total);

//mainThread m=new mainThread();
}

}

Answer 1

您正在每个线程实现中创建mainThread的新实例。这将是一个问题，因为他们不会分享相同的结果。你也不会把这个结果放在任何地方。

多线程是复杂的，并且会带来很多问题，所以我建议您阅读关于锁的文章；线程同步：https://www.tutorialspoint.com/java/java_multithreading.htmhttps://www.tutorialspoint.com/java/java_thread_synchronization.htm

[编辑]我在原来的答案中弄错了。计算所有这些总和的方法要简单得多：https://math.stackexchange.com/questions/593318/factorial-but-with-addition

Answer 2

您可以使用ForkJoinPool框架。定义返回值的RecursiveTask，并对处理后的子结果求和。

class SumRecursiveAction extends RecursiveTask<BigInteger> {
private static final int PIVOT = 1000;
private final int start;
private final int end;
private final List<Integer> list;
public SumRecursiveAction(List<Integer> list, int start, int end) {
this.start = start;
this.end = end;
this.list = list;
}
protected BigInteger compute() {
if (end - start <= PIVOT) {
// process if the range is within the pivot
BigInteger sum = BigInteger.ZERO;
for (int i = start; i < end; i++) {
sum = sum.add(BigInteger.valueOf(list.get(i)));
}
return sum;
} else {
// or else delegate the task, fork and join
int middle = start + ((end-start) / 2);
RecursiveTask<BigInteger> otherTask = new SumRecursiveAction(list, start, middle);
otherTask.fork();
return new SumRecursiveAction(list, middle, end)
.compute()
.add(otherTask.join());
}
}
}

用法：

List<Integer> list = IntStream.range(0, 100_000).boxed().collect(Collectors.toList());
ForkJoinTask<BigInteger> task = new SumRecursiveAction(list,0, list.size());
ForkJoinPool pool = new ForkJoinPool();
BigInteger sum = pool.invoke(task);

System.out.println("Sum: " + sum);