Java并发之线程封闭

读者们好！在这篇博客中，我们将探讨线程封闭是什么意思，以及我们如何实现它。所以，让我们直接开始吧。

1. 线程封闭

大多数的并发问题仅发生在我们想要在线程之间共享可变变量或可变状态时。如果在多个线程之间操作共享变量，则所有线程都将能够读取和修改变量的值，从而出现意外或不正确的结果。一种简单的避免此问题的方式是不在线程之间共享数据。这种技术称为线程封闭，是在我们的应用程序中实现线程安全的最简单方法之一。

Java 语言本身没有任何强制执行线程封闭的方法。线程封闭是通过不允许多个线程同时使用同一个状态的方式的程序设计来实现的，因此由程序实现强制执行。几种类型的线程封闭，如下所示：

1.1 Ad-Hoc 线程封闭

Ad-hoc 线程封闭描述了线程封闭的方式，由开发人员或从事该项目的开发人员确保仅在单个线程内使用此对象。这种方式方法可用性不高，在大多数情况下应该避免。

Ad-hoc 线程封闭下的一个特例适用于 volatile 变量。只要确保 volatile 变量仅从单个线程写入，就可以安全地对共享 volatile 变量执读 - 改 - 写操作。在这种情况下，您将修改限制在单个线程以防止竞争条件，并且 volatile 变量的可见性保证确保其他线程看到最新值。

1.2 栈封闭

栈封闭将变量或对象封闭在线程的栈中。这比 Ad-hoc 线程封闭强得多，因为它通过定义堆栈本身中的变量状态来进一步限制对象的范围。例如，请考虑以下代码：

private long numberOfPeopleNamedJohn(List<Person> people) {

  List<Person> localPeople = new ArrayList<>();

  localPeople.addAll(people);

  return localPeople.stream().filter(person -> person.getFirstName().equals("John")).count();

}

在上面的代码中，我们传递一个 person 对象的 list 但不直接使用它。相反，我们创建自己的 list，该 list 是当前正在执行的线程的本地 list，并将变量 people中的所有 person 添加到 localPeople。由于我们仅在 numberOfPeopleNamedJohn方法中定义列表，这使得变量localPeople 受到堆栈隔离保护，因为它只存在于一个线程的堆栈上，因此任何其他线程都无法访问它。这使得 localPeople 线程安全。唯一需要注意的是，不应该让 localPeople 的作用于超过这个方法的范围，以保证堆栈的隔离控制。在定义这个变量时，应该记录或注释为什么要定义这个变量，通常，只有在当前开发人员的脑海中才不让它超出方法的作用域，但是在将来，另一个开发人员可能会不知道为何如此设计而陷入困境。

1.3 ThreadLocal

ThreadLocal允许我们将每个线程 ID 与相应对象的值相关联。它允许我们为不同的线程存储不同的对象，并维护哪个对象对应于哪个线程。它有 set 和 get 方法，这些方法为使用它的每个线程维护一个单独的 value 副本。get() 方法总是返回从当前正在执行的线程传递给 set()的最新值。我们来看一个例子：

public class ThreadConfinementUsingThreadLocal {

    public static void main(String[] args) {

        ThreadLocal<String> stringHolder = new ThreadLocal<>();

        Runnable runnable1 = () -> {

            stringHolder.set("Thread in runnable1");

            try {

                Thread.sleep(5000);

                System.out.println(stringHolder.get());

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        };

        Runnable runnable2 = () -> {

            stringHolder.set("Thread in runnable2");

            try {

                Thread.sleep(2000);

                stringHolder.set("string in runnable2 changed");

                Thread.sleep(2000);

                System.out.println(stringHolder.get());

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        };

        Runnable runnable3 = () -> {

            stringHolder.set("Thread in runnable3");

            try {

                Thread.sleep(5000);

                System.out.println(stringHolder.get());

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        };

        Thread thread1 = new Thread(runnable1);

        Thread thread2 = new Thread(runnable2);

        Thread thread3 = new Thread(runnable3);

        thread1.start();

        thread2.start();

        thread3.start();

    }

}

在上面的例子中，我们使用相同的 ThreadLocal 对象 stringHolder 执行了三个线程。正如你在这里看到的，我们首先在 stringHolder 对象的每个线程中设置一个字符串，使其包含三个字符串。然后，经过一些暂停后，我们只更改了第二个线程的值。以下是该程序的输出：

string in runnable2 changed

Thread in runnable1

Thread in runnable3

正如您在上面的输出中所看到的，线程2的字符串已更改，但线程1和线程3的字符串未受影响。如果我们在从 ThreadLocal 获取特定线程的值之前没有设置任何值，那么它返回null。线程终止后，“ThreadLocal” 中特定于线程的对象就可以进行垃圾回收了。

这就是线程封闭。我希望这个博客对你有所帮助，一块学习新的东西。谢谢！

原文：https://dzone.com/articles/java-concurrency-thread-confinement

作者：Akshansh Jain

译者：KeepGoingPawn