共计 5408 个字符，预计需要花费 14 分钟才能阅读完成。
线程的优缺点
线程是系统调度的基本单位。线程如果使用得当，可以有效地降低程序的开发和维护等成本，同时提升复杂应用程序的性能。多线程程序可以通过提高处理器资源的利用率来提升系统的吞吐率。与此同时，在线程的使用开发过程中，也存在着诸多需要考虑的风险。
安全性：有合理的同步下，多线程的并发随机执行使线程安全性变得复杂，如 ++i。
活跃性：在多线程中，常因为缺少资源而处于阻塞状态，当某个操作不幸造成无限循环，无法继续执行下去的时候，就会发生活跃性问题。
性能：线程总会带来程序的运行时开销，多线程中，当频繁地出现上下文切换操作时，将会带来极大的开销。
线程安全性
线程安全的问题着重于解决如何对状态访问操作进行管理，特别是对共享和可变的状态。共享意味着可多个线程同时访问；可变即在变量在其生命周期内可以被改变；状态就是由某个类中的成员变量（Field）。
一个无状态的对象一定是线程安全的。因为它没有可被改变的东西。
public class LoginServlet implements Servlet {
public void service(ServletRequest req, ServletResponse resp) {
System.out.println(“ 无状态 Servlet，安全的类，没有字段可操作 ”);
}
}
原子性
正如我们熟知的 ++ i 操作，它包含了三个独立的“读取 - 修改 - 写入”操作序列，显然是一个复合操作。为此 java 提供了原子变量来解决 ++ i 这类问题。当状态只是一个的时候，完全可以胜任所有的情况，但当一个对象拥有两个及以上的状态时，仍然存在着需要思考的复合操作，尽管状态都使用原子变量。如下：
public class UnsafeCachingFactorizer implements Servlet {
private final AtomicReference<BigInteger> lastNumber =
new AtomicReference<BigInteger>();
private final AtomicReference<BigInteger[]> lastFactors =
new AtomicReference<BigInteger[]>();
public void service(ServletRequest req, ServletResponse resp) {
BigInteger i = extractFromRequest(req);
if (i.equals(lastNumber.get())) {
encodeIntoResponse(resp, lastFactors.get());
} else {
BigInteger[] factors = factor(i);
lastNumber.set(i);
lastFactors.set(factors);
encodeIntoResponse(resp, factors);
}
}
} // lastNumber lastFactors 虽然都是原子的，但是 if-else 是复合操作，属“先验条件”
既然是复合操作，最直接，简单的方式就是使用 synchronized 将这个方法同步起来。这种方式能到达预期效果，但效率十分低下。
既然提到 synchronized 加锁同步，那么就必须知道 锁的特点：
锁是可以重入的。即子类的同步方法可以调用本类或父类的同步方法。
同一时刻，只有一个线程能够访问对象中的同步方法。
静态方法的锁是 类；普通方法的锁是 对象本身。
回顾上面的代码，一个方法体中，只要涉及了多个状态的时候，就一定需要同步整个方法吗？答案是否定的，同步只是为了让多步操作为原子性，即对复合操作同步即可，因此需要明确的便是哪些操作是复合操作。如下：
public class CachedFactorizer implements Servlet {
private BigInteger lastNumber;
private BigInteger[] lastFactors;
private long hits;
private long cacheHits;
public synchronized long getHits() {
return hits;
}
public synchronized double getCacheHitRatio() {
return (double) cacheHits / (double) hits;
}
public void service(ServletRequest req, ServletResponse resp) {
BigInteger i = extractFromRequest(req);
BigInteger[] factors = null;
synchronized (this) {
++hits;
if (i.equals(lastNumber)) {
++cacheHits;
factors = lastFactors.clone();
}
}
if (factors == null) {
factors = factor(i);
synchronized (this) {
lastNumber = 1;
lastFactors = factors.clone();
}
}
encodeIntoResponse(reqsp, factors);
}
}// 两个 synchronized 分别同步独立的复合操作。
对象共享
重排序：当一个线程修改对象状态后，其他线程没有看见修改后的状态，这种现象称为“重排序”。
java 内存模型允许编译器对操作顺序进行重排序，并将数据缓存在寄存器中。当缺乏同步的情况下，每一个线程在独立的缓存中使用缓存的数据，并不知道主存中的数据已被更改。这就涉及到内存可见性的问题。
可见性
内存可见性：同步的另一个重要的方面。我们不仅希望防止多个线程同时操作对象状态，而且还希望确保某一个线程修改了状态后，能被其他线程看见变化。
volatile：使用 synchronized 可以实现内存可见，但 java 提供了一种稍弱的更轻量级得同步机制 volatile 变量。在访问 volatile 变量时不会执行加锁操作，因此不会产生线程阻塞。即便如此还是不能过度使用 volatile，当且仅当能简化代码的实现以及对同步策略的验证时，才考虑使用它。
发布与逸出
发布指：使对象能够在当前作用于之外的代码中使用。即对象引用能被其他对象持有。发布的对象内部状态可能会破坏封装性，使程序难以维持不变性条件。
逸出指：当某个不应该发布的对象被发布时，这种情况被称为逸出。
// 正确发布：对象引用放置公有静态域中，所有类和线程都可见
class CarFactory {
public static Set<Car> cars;
private CarFactory() {
cars = new HashSet<Car>();
} // 私有，外部无法获取 CarFactory 的引用
public static Car void newInstance() {
Car car = new Car(“ 碰碰车 ”);
cars.put(car);
return car;
} // 使用方法来获取 car
}
// 逸出
class Person {
private String[] foods = new String[] {“ 土豆 ”};
public Person(Event event) {
person.registListener {
new EventListener() {
public void onEvent(Event e) {
doSomething(e);
}
}
}
}// 隐式逸出了 this，外界得到了 Person 的引用 并且 EventListener 也获取了 Person 的引用。
public String[] getFoods() {
return foods;
}// 对发布的私有 foods，外界还是可以修改 foods 内部值
}
线程封闭
将可变的数据仅放置在单线程中操作的技术，称之为发线程封闭。
栈封闭：只能通过局部变量才能访问对象。局部变量的固有属性之一就是封装在执行线程中，它们位于执行线程的栈中，其他线程无法访问这个栈，即只在一个方法内创建和使用对象。
public int test(Person p) {
int num = 0;
PersonHolder holder = new PersonHolder();
Person newPerson = deepCopy(p);
Person woman = holder.getLove(newPerson);
newPerson.setWomen(person);
num++;
return num; // 基本类型没有引用, 对象创建和修改都没有逸出本方法
}
ThreadLocal 类：ThreadLocal 能够使线程中的某个值与保存值的对象关联起来。ThreadLocal 提供了 get、set 等访问接口的方法，这些方法为每一个使用该变量的线程都存有一份独立的副本，因 get 总是返回由当前执行线程在调用 set 时设置的最新值。
private static ThreadLocal<Connection> connectionHolder =
new ThreadLocal<Connection>() {
public Connection initialValue() {
return DriverManager.getConnection(DB_URL);
}
};
public static Connection getConnection() {
return connectionHolder.get();
}
当某个频繁执行的操作需要一个临时对象，例如一个缓冲区，而同时又希望避免在每次执行时都重新分配该临时对象，就可以使用 ThreadLocal。
不变性
线程安全性是不可变对象的固有属性之一。不可变对象一定是线程安全的，它们的不变性条件是由构造函数创建的，只要它们的状态不可变。
// 在可变对象基础上构建不可变类
public final class ThreadStooges {
private final Set<String> stooges = new HashSet<String>();
public ThreadStooges() {
stooges.add(“Moe”);
stooges.add(“Larry”);
}
public boolean isStooge(String name) {
return stooges.contains(name);
}
}// 没有提供可修改状态的方式，尽管使用了 Set 可变集合，但被 private final 修饰着
对象不可变的条件
对象创建以后其状态就不能修改。
对象的所有域都是 final 类型。
对象是正确创建的（在对象的创建期间，this 引用没有逸出）
安全发布
任何线程都可以在不需要额外同步的情况下安全地访问不可变对象，即使在发布这些对象时没有使用同步。
// 安全的 Holder 类
class Holder {
private int n;
public Holder(int n) {
this.n = n;
}
}
public class SessionHolder {
// 错误的发布，导致 Holder 不安全
public Holder holder;
public void init() {
holder = new Holder(10);
}
}// 当初始化 holder 的时候，holder.n 会被先默认初始化为 0，然后构造函数才初始化为 10；在并发情况下，可能会有线程在默认初始化 与 构造初始化中，获取到 n 值为 0，而不是 10；
要安全的发布一个对象，对象的引用以及对象的状态必须同时对其他线程可见。一个正确构造的对象可以通过以下方式安全发布：
在静态初始化函数中初始化一个对象引用。
将对象的引用保存到 volatitle 类型的域或者 AtomicReferance 对象中。
将对象的引用保存到某个正确构造对象的 final 类型域中。
将对象的引用保存到一个由锁保护的域中。
在线程并发容器中的安全发布：
通过将一个键或者值放入 Hashtable、synchronizedMap 或者 ConsurrentMap 中，可以安全地将它发布给任何从这些容器中访问它的线程（无论是直接访问还是通过迭代器访问）。
通过将某个元素放入 Vector、CopyOnWriteArrayList、CopyOnWriteArraySet、synchronizedList 或 synchronizedSet 中，可以将元素安全地发布到任何从这些容器中访问该元素的线程。
通过将某个元素放入 BlockingQueue 或者 ConcurrentLinkedQueue 中，可以将该元素安全地发布到任何从这些队列中访问该元素的线程。
通常，要发布一个静态构造的对象，最简单、安全的方式就是使用静态的初始化器。如 public static Holder holder = new Holder(10)。如果对象在发布后状态不会被修改（则称为事实不可变对象），那么在没有额外的同步情况下，任何线程都可以安全地使用被安全发布的不可变对象。
对象的发布需求取决于它的可变性：
不可变对象可以通过任意机制来发布。
事实不可变对象必须通过安全方式来发布。
可变对象必须通过安全方式来发布，并且必须是线程安全的或者有某个锁保护起来。
在并发程序中使用和共享对象时可采用的策略：
线程封闭。将对象封闭在线程中，如在方法中创建和修改局部对象。
只读共享。
线程安全共享。对象内部实现同步，使用公有接口来访问。
保护对象。使用特定的锁来保护对象。
