Question

我现在正在学习并发性，并且我尝试编写一个程序，它应该在使用并发集合时演示发生在之前的关系。如 java.concurrent 包中所述：

java.util.concurrent及其子包中所有类的方法将这些保证扩展到更高级别的同步。在特别是：在将对象放入任何对象之前的线程中的操作并发收集发生在访问之后的操作之前或从另一个帖子中的集合中删除该元素。

我写了下一堂课：

import java.util.Deque;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.atomic.AtomicBoolean;

public class HappensBefore {
    static int      checks      = 0;
    static int      shouldNotHappen   = 0;

    static Deque<Integer> syncList    = new LinkedBlockingDeque<>();
    public static boolean varToHappenBefore = false; //this var must be false when new element added to collection

    static AtomicBoolean  flag        = new AtomicBoolean();

    static class SyncTask implements Runnable {

    int       localTemp = -1;
    private final Thread t   = new Thread(new Counter());

    @Override
    public void run() {
        t.start();
        while (syncList.isEmpty()) { //just skip
        }

        while (true) {
        if (!Thread.interrupted()) {
            if (flag.get()) {
            int r = syncList.peekLast();
            if (r != localTemp) {
                if (varToHappenBefore) {
                shouldNotHappen++;
                }
                varToHappenBefore = true;
                localTemp = r;
                checks++;
            }
            flag.set(false);
            }
        } else {
            t.interrupt();
            break;
        }
        }
    }
    }

    static class Counter implements Runnable {
    int ctr = 0;

    @Override
    public void run() {
        while (!Thread.interrupted()) {

        if (!flag.get()) {
            flag.set(true);
            varToHappenBefore = false;
            syncList.add(ctr++);
        }
        }
    }
    }


    public static void main(String[] args) throws InterruptedException {
    SyncTask st = new SyncTask();
    Thread s = new Thread(st);
    s.start();
    Thread.sleep(10000);//runtime ms

    s.interrupt();
    // s1.interrupt();
    System.out.println("Elems times added: " + checks);
    System.out
        .println("Happens-before violated times: " + shouldNotHappen);
    }
}

我做的是启动thread1，它引发了thread2。 Thread1检查最初设置为false的公共布尔 varToHappenBefore 。当thread1从集合中保存新元素时，它将此布尔值设置为true。在下一个新的元素。收到此布尔值是否仍然为真，发生在违规发生之前，并且 shouldNotHappen 会增加。

Thread1检查并发集合是否具有新元素，如果是，则将其保存在temp var中并增加整体计数器检查。然后它切换原子布尔值，让thread2添加新元素。在添加新元素之前， varToHappenBefore 设置为false。由于原子布尔标志，thread2不会在thread1之前运行代码。但是在添加元素并检查 varToHappenBefore 之前，在thread2中切换标志，因为这两个操作（elem add和boolean toggle）通过原子布尔同步。我确保thread1在thread1运行后只运行一次。如果在添加elem之前发生 varToHappenBefore 。 to thread2中的集合，然后在thread1中读取（thread1仅在从集合中读取新elem时检查 varToHappenBefore ），然后 varToHappenBefore 在程序结束后必须保持为0。但我得到了下一个结果：

增加了几次：~10 000 000

发生在违规时间之前：0-10

可能我做错了，多线程是微妙而复杂的。希望得到你的帮助。

修改当thread1 setFlag(false)在它之后是真的并且在获得elem之前我需要逃避这种情况。来自集合，因为thread2可以在从集合中获取元素和在线程1中设置varToHappenBefore = true;之间工作。如果我使AtomicBoolean.compareAndSet()检查块，那么每8mils我得到80k失败。它是可预测和清晰的。但是当我没有为thread2添加这样一个窗口来在从集合读取和设置布尔值之间添加额外元素时，我仍然得到很少的顺序读取，当布尔值为true并且出现新元素时。

Answer 1

您的示例分析和修复有点复杂。但是，如果您只是为了理解并发收集时发生在事前的合同，那么请尝试这个程序 -

public class HappensBeforeTest {

private static boolean producerStopped;

private static final Queue<String> queue = new LinkedBlockingQueue<>();
//private static final Queue<String> queue = new LinkedList<>();

public static void main(String[] args) {
    new Thread(new Producer()).start();
    new Thread(new Consumer()).start();
}

private static class Producer implements Runnable {

    public void run() {
        int count = 0;
        while (count++ < 10) {
            producerStopped = (count == 10);
            queue.add(String.valueOf(count));
        }
        System.out.println("Producer finished");
    }
}

private static class Consumer implements Runnable {

    public void run() {
        while (!producerStopped) {
            queue.poll();
        }
        System.out.println("Consumer finished");
    }
}

}

当queue为LinkedBlockingQueue时，线程Producer和Consumer都已完成。

但当queue为LinkedList时有时Consumer无法完成并继续运行，因为producerStopped标志仍然可见为Consumer的假，即使{ {1}}已将其更新为true。

Answer 2

即使发现列表尚未更改，您的SyncTask也会清除flag。所以，你可能会错过列表添加事件。这使您的假设不正确：

错过事件后的下一轮，SyncTask发现列表已更改，它假定Counter已完成任务，检查（成功）并重新安装varToHappenBefore。但是Counter实际上将元素添加到之后的列表中。

下一轮SyncTask创建列表再次更改，它假定Counter已完成其任务，检查varToHappenBefore并发现它未被清除。这只是因为Counter还没有清除它。

只需将flag.set(false);移至if (r != localTemp)区块即可，一切正常。

Answer 3

最干净的演示非常简单。让线程A创建一个可变类的实例，更新它，并put(...)它到队列。然后，让线程B从队列中删除实例，并验证对象的状态是否符合预期。

并发收集发生在关系之前

3 个答案: