Java并发中线程封闭知识点详解

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

线程封闭基础知识点

实现好的并发是一件困难的事情，所以很多时候我们都想躲避并发。避免并发最简单的方法就是线程封闭。什么是线程封闭呢？

就是把对象封装到一个线程里，只有这一个线程能看到此对象。那么这个对象就算不是线程安全的也不会出现任何安全问题。实现线程封闭有哪些方法呢？

1：ad-hoc线程封闭

这是完全靠实现者控制的线程封闭，他的线程封闭完全靠实现者实现。也是最糟糕的一种线程封闭。所以我们直接把他忽略掉吧。

2：栈封闭

栈封闭是我们编程当中遇到的最多的线程封闭。什么是栈封闭呢？简单的说就是局部变量。多个线程访问一个方法，此方法中的
局部变量都会被拷贝一分儿到线程栈中。所以局部变量是不被多个线程所共享的，也就不会出现并发问题。所以能用局部变量就别用全局的变量，全局变量容易引起并发问题。

3：ThreadLocal封闭

使用ThreadLocal是实现线程封闭的最好方法，有兴趣的朋友可以研究一下ThreadLocal的源码，其实ThreadLocal内部维护了一个Map，Map的key是每个线程的名称，而Map的值就是我们要封闭的对象。每个线程中的对象都对应着Map中一个值，也就是ThreadLocal利用Map实现了对象的线程封闭。这里就不说ThreadLocal的使用方法了，度娘一下便知。

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” 中特定于线程的对象就可以进行垃圾回收了。