线程安全读/写计数器

Question

我正在尝试使用线程安全方法创建 2 个线程来读取/写入计数器。

我已经编写了一些代码来尝试对此进行测试，但读取线程只是在其最大值 (1000) 处读取计数器

主要：

public static void main(String[] args) {

    Counter c = new Counter();

    Thread inc = new Increment(c);
    Thread read = new Read(c);

    inc.start();
    read.start();

}

计数器：

public class Counter {

private int count;

public Counter() {
    count = 0;
}

public synchronized void increment() {
    count++;
}

public synchronized int getVal() {
    return count;
}

}

增量：

public class Increment extends Thread {

private static final int MAX = 1000;
private Counter myCounter;

public Increment(Counter c) {
    myCounter = c;
}

public void run() {
    for (int i = 0; i < MAX; i++) {
        myCounter.increment();
    }
}
}

阅读：

public class Read extends Thread {

private static final int MAX = 1000;
private Counter myCounter;

public Read(Counter c) {
    myCounter = c;
}

public void run() {
    for (int i = 0; i < MAX; i++) {
        System.out.println(myCounter.getVal());
    }
}
}

使用 Atomic Integer 来保存计数器的值以允许我安全地递增并获取值会更好吗？

Answer 1

您的代码完全没有问题。碰巧您的增量线程在读取线程有机会读取之前完成了所有增量。 1000 个增量几乎不需要任何时间。

Answer 2

如果您希望更频繁地交错执行 Read 线程和 Increment 线程，然后自然操作系统线程抢占，只需让每个线程放弃它们的锁（通过在各自的run() 方法中调用<lockedObject>.wait() 后跟<lockedObject>.notify() 或notifyAll()：

[在阅读器中]：

public void run() {
    for (int i = 0; i < MAX; i++) {
        synchronized (myCounter) {
            System.out.println(myCounter.getVal());
            try {
                myCounter.wait(0L, 1);
                myCounter.notifyAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

[增量]：

public void run() {
    for (int i = 0; i < MAX; i++) {
        synchronized (myCounter) {
            myCounter.increment();
            try {
                myCounter.wait(0L, 1);
                myCounter.notifyAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

将MAX 常数提高到1_000_000_000（10 亿）使胎面时不时地交错（在我的机器上，交错只是通过观察 150 和 400_000 次迭代）。