java - 并发设置界限

Question

我对并发还很陌生，但现在已经了解了它的要点；我有一个非线程安全的程序，因此类的不变量(主要是下界小于等于上限)可能会被打破。我想出了一个小主要方法，希望当这是真的时它会打印出 false，但无法弄清楚为什么它不会。

public class Conc implements Runnable {

    // Invariant: lower <= upper
    private final AtomicInteger lower = new AtomicInteger(0);
    private final AtomicInteger upper = new AtomicInteger(0);

    public void setLower(int l) {
        if (l <= upper.get())
            lower.set(l);
    }

    public void setUpper(int u) {
        if (u >= lower.get())
            upper.set(u);
    }

    public boolean isInRange(int i) {
        return (i >= lower.get() && i <= upper.get());
    }

    public boolean invariantSatisfied() {
        return (lower.get() <= upper.get());
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new Conc());
        Thread t2 = new Thread(new Conc());
        Thread t3 = new Thread(new Conc());

        t1.start();
        t2.start();
        t3.start();
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000000; i++) {
            setUpper(i - 10000);
            setLower(i + 800000);
            if (invariantSatisfied() == false) {
                System.out.println("False");
            }
            System.out.println();
        }
    }
}

Answer 1

此程序存在一些问题，导致出现意外结果。

首先指出的是代码实际上是线程安全的。这是因为每个对象都有自己的一组引用的字段，并且每个线程都有自己的对象。

可以通过多种方式解决这个问题

您可以在每个线程中使用相同的对象

  Conc target = new Conc ();
  Thread t1 = new Thread(target);
  Thread t2 = new Thread(target);
  Thread t3 = new Thread(target);
  t1.start();
  t2.start();
  t3.start();

或者您可以将字段设为静态，这意味着只有一个实例

private static final AtomicInteger lower = new AtomicInteger(0);
private static final AtomicInteger upper = new AtomicInteger(0);

您遇到的另一个问题是，即使该程序不是线程安全的，测试失败的窗口也很小，因此很少会因输入数据而失败。

for(int i = 0; i < 1000000; i++){
    setUpper(i);
    setLower(i);
    if(!invariantSatisfied()){
        System.out.println("False");
    }
}

解决了这个问题。