1

我现在正在学习并发性，并且我尝试编写一个程序，该程序应该在使用并发收集时演示发生之前的关系。如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 之前运行代码。但是在 thread2 中切换标志是在添加元素和检查varToHappenBefore之前完成的，因为这两个操作（elem add 和 boolean toggle）否则通过 atomic boolean 同步。我确保 thread2 在 thread1 运行后只运行一次。如果varToHappenBefore发生在添加元素之前。在thread2中收集，然后在thread1中读取（thread1检查varToHappenBefore仅当从集合中读取新元素时），那么varToHappenBefore必须在程序结束后保持为 0。但我得到下一个结果：

添加元素次数：~10 000 000

违规前发生次数：0-10

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

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

4

3 回答 3

3

您的示例分析和修复有点复杂。但是，如果您这样做只是为了了解在并发收集的情况下发生之前的合同，那么试试这个程序 -

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完成。

但是 when queueisLinkedList有时Consumer不会完成并继续运行，因为即使已将其更新为 true ，该producerStopped标志仍​​然可见为 false 。ConsumerProducer

于 2015-09-07T17:39:05.403 回答
1

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

  1. 在丢失事件后的下一轮，SyncTask发现列表已更改，它假定Counter已完成任务，检查（成功）并重新设置varToHappenBefore。但实际上在那之后Counter将元素添加到列表中。
  2. 下一轮SyncTask创建列表又变了，它假设Counter已经完成了它的任务，检查varToHappenBefore发现它没有被清除。这只是因为Counter还没有清除它。

只要flag.set(false);进入if (r != localTemp)街区，一切都会奏效。

于 2015-09-07T07:51:21.840 回答
0

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

于 2015-09-07T15:32:41.370 回答