使用多线程计算Java中的1万个整数之和

Question

我想用多线程计算一万个整数的和（从1到10000）。我对同步密钥工作有基本的了解。我知道 synchronized 在执行期间一次只允许一个线程，而 semaphore 一次允许一定数量的线程。

这是我使用 synchronized 关键字的实现：

public class Testing {
private static int sum = 0;
private static int one = 1;
public synchronized static void increment() {
    sum = sum + one;
    one++;
}
public static void main(String[] args) {
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 5000; i++) {
                increment();
            }
        }
    });
    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 5000; i++) {
                increment();
            }
        }
    });
    t1.start();;
    t2.start();
    try {
        t1.join();
        t2.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(sum);
  }
}

我的解决方法：将10000这个数字分成两部分。使用两个线程计算每个部分。

问题：有没有更好的方法通过使用信号量来做到这一点？我在这里使用了同步，但我们应该使用信号量吗？这种情况下我们应该如何使用信号量来改进呢？

Answer 1

如果您想对整数求和，请查看 ForkJoinTask

如果您想了解信号量的用法，请检查 Semaphore simple sample

编辑： 将您的 increment() 更改为

public static void increment() 
    {
        try
        {
            semaphore.acquire();
        }
        catch (InterruptedException e)
        {
            //process excp
        }
        sum = sum + one;
        one++;
        semaphore.release();
    }

并添加

private static Semaphore semaphore = new Semaphore(1);

作为class变量

但正如其他人指出的那样，这不是拆分问题的正确方法。 此外，如果您正在寻找 wait()/notify() 信号量模型，您仍然需要使用同步。

使用多线程计算Java中的1万个整数之和

Use multi-threading to calculate sum of 10 thousand integers in Java

java

multithreading

mutex

semaphore

synchronized