Question

我有一个“计数器”类，它将计数器递增到一个限制。我创建了这个类的N个实例，每个类都将计数器增加到MAX_COUNT / N.我已经实现了synchronized方法，但是计数器永远不会达到MAX_COUNT值（我将发布代码，这将有助于理解问题）

Main.java

package monitores;

// MAIN PROGRAM, IT CREATES THE THREADS, RUNS THEM AND JOINS, AT THE END
// DISPLAYS THE COUNTER VALUE

public class Main {


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

        Hilo hilos[] = new Hilo[Hilo.NUM_THREADS];
        for(int i = 0; i < Hilo.NUM_THREADS; i++){
            hilos[i] = new Hilo();
            hilos[i].start();
        }

        for(int i = 0; i < Hilo.NUM_THREADS; i++){
            hilos[i].join();
        }

        System.out.println("Counter value at the end: "+Hilo.count());
    }

}

Hilo.java

package monitores;


public class Hilo extends Thread {

    public static final int MAX_COUNT = 40000;
    public static final int NUM_THREADS = 4;

    private static volatile int count = 0;

    public static int count() {
        return count;
    }


    @Override
    public void run() {
        int max = MAX_COUNT / NUM_THREADS;
        for (int i = 0; i < max; i++) {
            synchronized(this){
                count++;
            }
        }
    }
}

如果我运行Main.java，结果如下：

Counter value at the end: 33870

这是一个随机数，但总是接近MAX_COUNT。

提前谢谢。

Answer 1

您的主题只是自己同步。他们所做的只是锁定自己并增加，因此代码不是线程安全的。

他们需要在一个共同的对象上进行同步。在这种情况下，.class对象是合理的。每个线程都可以轻松访问要锁定的单个对象：

synchronized(Hilo.class){
    count++;
}

替代方法不是同步，而是用AtomicInteger替换count的数据类型。 getAndIncrement()增加。

Answer 2

这闻起来就像一场竞争。如果每次都有随机值，则意味着不同的线程在同一时刻写入同一个变量。

如果我有两个线程，您需要同步共享变量或创建一个同步方法，他们都需要使用它来更新计数。

Answer 3

但计数器永远不会达到MAX_COUNT值（我将发布代码，这将有助于理解问题）

问题是@rgettman提到您正在this上进行同步，这是每个线程而不是像类这样的共享对象。

另一个解决方案是切换到使用AtomicInteger来处理同步和内存共享：

private static AtomicInteger count = new AtomicInteger(0);
...
public static int count() {
    return count.get();
}
...
for (int i = 0; i < max; i++) {
    // no need for synchronization object here
    count.incrementAndGet();
}

Java线程和同步问题

3 个答案: