Question

我正在编写一个演示程序来解释如何在Java中调节一组线程的并发性，但结果并不像我预期的那样。这是代码：

package parcountSyncStat;
public class Parcount extends Thread {
   private static int N=1000;
   private static Integer x=0;

   public static void main(String[] args) throws InterruptedException {
       Thread[] t = new Thread[N];
       int i;
       for (i = N-1; i >= 0; i--) { 
       t[i]=new Parcount(); 
           t[i].start();
       }
       for ( i=N-1; i>=0; i-- ) t[i].join();
       System.out.println(x);
    }
    public void run() { synchronized(x) { x++; } }
}

简而言之，1000个线程尝试增加相同的整数x。为了保持一致性，我将同步块中的增量包含在内。父线程等待所有进程完成，然后打印x的最终值，该值应为1000.但事实并非如此。我的问题是：为什么？我在某处错了吗？

请注意，我通过实现一个用同步“Increment”方法封装整数的类来获得预期的结果。但是用锁定/解锁对替换 synchronized 也不起作用。我正在使用Eclipse并且尝试了openjdk和oracle jdk，结果相似。

由于

Answer 1

x++创建一个新的Integer对象 - 因此每次运行该语句时，使用的锁都会变得不同。如果您想为所有线程创建一个锁，请创建一个ad hoc对象：

private static final Object lock = new Object();

并同步lock。

Answer 2

感谢assylias：这是完整的代码：

public class Parcount extends Thread {
private static int N=1000;
private static Integer x=0;
private static final Object lock = new Object();

public static void main(String[] args) 
        throws InterruptedException {
    Thread[] t = new Thread[N];
    int i;
      for ( i=N-1; i>=0; i-- ) { 
        t[i]=new Parcount(); 
        t[i].start();
    }
    for ( i=N-1; i>=0; i-- ) t[i].join();
    System.out.println(x);
}
public void run() { synchronized(lock) { x++; } }

}

Answer 3

以下代码使用共享资源x的所有者（类Example）作为要同步的实例。您可以尝试更改代码：

public class Example extends Thread {

    public static void main(String[] args) throws InterruptedException {
        Thread[] t = new Thread[N];
        for (int i = N - 1; i >= 0; i--) {
            t[i] = new Example();
            t[i].start();
        }
        for (int i = N - 1; i >= 0; i--) t[i].join();
        System.out.println(x);
    }

    private static int N = 1000;
    private static int x = 0;

    @Override public void run() {
        synchronized (Example.class) { x++; }
    }
}

用Java同步人群

3 个答案: