在 Java 中从多个线程读取（而不是修改）不是线程安全的对象（如链表）是否安全？

Question

已经有一个question whether threads can simultaneously safely read/iterate LinkeList。似乎答案是肯定的，只要没有人从链表中对其进行结构更改（添加/删除）。

虽然一个答案是警告“未刷新的缓存”并建议了解“Java 内存模型”。所以我要求详细说明那些“邪恶”的缓存。我是一个新手，到目前为止我仍然天真地认为以下代码是可以的（至少从我的测试来看）

public static class workerThread implements Runnable {
    LinkedList<Integer> ll_only_for_read;
    PrintWriter writer;
    public workerThread(LinkedList<Integer> ll,int id2) throws Exception {
        ll_only_for_read = ll;
        writer = new PrintWriter("file."+id2, "UTF-8");
    }
    @Override
    public void run() {
        for(Integer i : ll_only_for_read) writer.println(" ll:"+i);
        writer.close();
    }
}

public static void main(String args[]) throws Exception{
    LinkedList<Integer> ll = new LinkedList<Integer>();
    for(int i=0;i<1e3;i++) ll.add(i);
    // do I need to call something special here? (in order to say:
    // "hey LinkeList flush all your data from local cache
    // you will be now a good boy and share those data among
    // whole lot of interesting threads. Don't worry though they will only read
    // you, no thread would dare to change you"
    new Thread(new workerThread(ll,1)).start();
    new Thread(new workerThread(ll,2)).start();
}

Answer 1

是的，在您的特定示例代码中没关系，因为创建新线程的行为应该定义填充列表和从另一个线程读取它之间的发生前关系。但是，设置可能不安全。

我强烈推荐阅读 Brian Goetz 等人的“Java Concurrency in Practice”以了解更多详细信息。

Answer 2

虽然一个答案是警告“未刷新缓存”并建议了解“Java 内存模型”。

我认为您指的是我对这个问题的回答：Can Java LinkedList be read in multiple-threads safely?。

所以我要求详细说明那些“邪恶”的缓存。

他们并不邪恶。它们只是生活中的事实......它们会影响多线程应用程序的正确性（线程安全）推理。

Java 内存模型是 Java 对这一生活事实的回答。内存模型以数学精度指定了一系列需要遵守的规则，以确保应用程序的所有可能执行都是“格式良好的”。 （简单来说：您的应用程序是线程安全的。）

Java 内存模型……很难。

有人推荐了 Brian Goetz 等人的“Java Concurrency in Practice”。我同意。它是编写“经典”Java 多线程应用程序主题的最佳教科书，对 Java 内存模型有很好的解释。

更重要的是，Goetz 等人为您提供了一组更简单的规则，这些规则足以为您提供线程安全。这些规则仍然过于详细，无法浓缩成 StackOverflow 答案……但是

• 其中一个概念是“安全发布”，并且
• 其中一个原则是使用/重用现有的并发构造，而不是基于内存模型滚动您自己的并发机制。

我是新手，到目前为止我仍然天真地认为以下代码是可以的。

它>>是

（至少从我的测试中）

... 测试并不能保证任何事情。非线程安全程序的问题在于，错误经常无法通过测试揭示出来，因为它们是随机出现的，概率很低，而且在不同平台上往往不同。

您不能依靠测试来告诉您您的代码是线程安全的。您需要对行为进行推理¹...或遵循一套有根据的规则。

---

^{1 - 我的意思是真实的、有根据的推理......不是凭直觉的东西。}

Answer 3

如果您的代码使用单个线程创建并填充列表，并且仅在第二个时刻您创建了同时访问该列表的其他线程，则没有问题。

只有当一个线程可以修改一个值而其他线程尝试读取相同的值时才会出现问题。

如果您更改您检索的对象（如果您不更改列表本身），这可能会出现问题。

Answer 4

你使用它的方式很好，但只是巧合。

程序很少那么简单：

• 如果列表包含对其他（可变）数据的引用，那么您将获得竞争条件。
• 如果有人在代码生命周期的后期修改了您的“阅读器”线程，那么您将面临竞争。

根据定义，不可变数据（和数据结构）是线程安全的。 然而，这是一个可变列表，即使你与自己达成了不修改它的协议。

我建议像这样包装List<> 实例，这样如果有人尝试使用列表中的任何突变器，代码就会立即失败：

List<Integer> immutableList = Collections.unmodifiableList(ll); //...pass 'immutableList' to threads.

链接到unmodifiableList

Answer 5

您需要保证 LinkedList 中读取和写入之间的发生前关系，因为它们是在单独的线程中完成的。

ll.add(i) 的结果对于新的 workerThread 是可见的，因为 Thread.start 形成了先发生关系。所以你的例子是线程安全的。查看更多关于happens-before conditions的信息。

但是要注意更复杂的情况，当在工作线程的迭代过程中读取 LinkedList 并同时被主线程修改时。像这样：

for(int i=0;i<1e3;i++) {
    ll.add(i);
    new Thread(new workerThread(ll,1)).start();
    new Thread(new workerThread(ll,2)).start();
}

这种方式 ConcurrentModificationException 是可能的。

有几种选择：

1. 在 workerThread 中克隆您的 LinkedList 并迭代副本 反而。
2. 对列表修改和列表使用同步 迭代（但会导致并发性差）。
3. 使用 CopyOnWriteArrayList 代替 LinkedList。

Answer 6

很抱歉回答我的问题。但我在考虑你令人放心的答案，我发现它可能不像看起来那么安全。我发现并测试了它不工作的情况 - 如果对象将使用它的类变量来存储任何数据（我不知道），那么它将失败（那么唯一的问题是链表（和其他 java 类）是否在一些实现可以做到...）见失败的例子：

public class DummyLinkedList {
    public LinkedList<Integer> ll;
    public DummyLinkedList(){
        ll = new LinkedList<Integer>();
    }
    int lastGetIndex;
    int myDummyGet(int idx){
        lastGetIndex = idx;
        //return ll.get(idx); // thids would work fine as parameter is on the stack so uniq for each call (at least if java supports reentrant functions)
        return ll.get(lastGetIndex); // this would make a problem even for only readin the object - question is how many such issues java.* contains
    }
}

Answer 7

这取决于对象是如何被创建并提供给你的线程的。一般来说，不，这不安全，即使对象没有被修改。

以下是一些使其安全的方法。

首先，创建对象并执行任何必要的修改；如果不再发生修改，您可以认为该对象实际上是不可变的。然后，通过以下方式之一与其他线程共享有效的不可变对象：

• 让其他线程从volatile 的字段中读取对象。
• 在synchronized 块内写入对对象的引用，然后让其他线程在synchronized 在同一个锁上读取该引用。
• 对象初始化后启动读取线程，将对象作为参数传递。 （这就是您在示例中所做的，因此您是安全的。）
• 使用并发机制（如BlockingQueue 实现）在线程之间传递对象，或将其发布到并发集合中，如ConcurrentMap 实现。

可能还有其他人。或者，您可以将共享对象的所有字段设为final（包括其Object 成员的所有字段，等等）。然后通过任何方式跨线程共享这个对象都是安全的。这是不可变类型被低估的优点之一。

Answer 8

如果您只能通过“读取”方法（包括迭代）访问列表，那么您就可以了。就像在你的代码中一样。