(1) 访问共享的可变数据时, 通常就需要同步

(2) 为了避免同步, 可以不共享数据, 在单线程内访问拘束的话就不需要共享数据, 这就叫线程封闭

线程封闭的方式

(1) Ad-hoc封闭: 完全交给程序实现者承担

尽量少用这种方式

(2) 栈封闭: 只能通过局部变量访问对象

示例

  public class Animals {

      ...

      public int loadTheArk(Collection<Animal> candidates) {

          SortedSet<Animal> animals;
          int numPairs = 0;
          Animal candidate = null;

          // animals confined to method, don't let them escape!
          animals = new TreeSet<Animal>(new SpeciesGenderComparator());
          animals.addAll(candidates);
  
          for (Animal a : animals) {

              if (candidate == null || !candidate.isPotentialMate(a)) {
                  candidate = a;
              } else {
                  ark.load(new AnimalPair(candidate, a));
                  ++numPairs;
                  candidate = null;
              }
          }
          
          return numPairs;
      }
  }

这个示例中, 输入参数 candidates 是共享的数据, 而栈封闭的意思是访问对象只能通过局部变量, 因此示例中使用局部变量animals作为candidates的副本，所有的访问都发生在局部变量animals上, 这样根本就不会共享数据。

使用栈封闭的风险是: 需求必须明确, 否则很有可能被后续的维护人员错误将对象逸出(例如示例中将candidates或者animals传到了其他线程中)

(2) 使用ThreadLocal类

1° JavaDoc说明

This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its {@code get} or {@code set} method) has its own, independently initialized copy of the variable. {@code ThreadLocal} instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID).

For example, the class below generates unique identifiers local to each thread. A thread's id is assigned the first time it invokes {@code ThreadId.get()} and remains unchanged on subsequent calls.

  class ThreadId {

      // Atomic integer containing the next thread ID to be assigned
      private static final AtomicInteger nextId = new AtomicInteger(0);

      // Thread local variable containing each thread's ID
      private static final ThreadLocal<Integer> threadId = new ThreadLocal<Integer>() {
              @Override
              protected Integer initialValue() {
                  return nextId.getAndIncrement();
              }
          };

      // Returns the current thread's unique ID, assigning it if necessary
      public static int get() {

          return threadId.get();
      }
  }

Each thread holds an implicit reference to its copy of a thread-local variable as long as the thread is alive and the {@code ThreadLocal} instance is accessible; after a thread goes away, all of its copies of thread-local instances are subject to garbage collection (unless other references to these copies exist).

2° 从概念上看, ThreadLocal<T>相当于内置了Map<Thread, T>, 其中保存了特定于当前线程的值

3° 如果需要将一个单线程应用程序移植到多线程环境中，可以将共享的变量转换为ThreadLocal对象

4° 示例

  public class ConnectionDispenser {

      static String DB_URL = "jdbc:mysql://localhost/mydatabase";

      private ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {

          @Override
          protected Connection initialValue() {

              try {
                  return DriverManager.getConnection(DB_URL);
              } catch (SQLException e) {
                  throw new RuntimeException("Unable to acquire Connection, e");
              }
          }
      };


      public Connection getConnection() {

          return connectionHolder.get();
      }
  }

这样, 每个线程都会拥有属于自己的Connection对象副本, 它们互不干扰