031.[转] 从类状态看Java多线程安全并发
从类状态看Java多线程安全并发
对于Java开发人员来说，i++的并发不安全是人所共知，但是它真的有那么不安全么？
在开发Java代码时，如何能够避免多线程并发出现的安全问题？这是所有Java程序员都会面临的问题。本文讲述了在开发Java代码时安全并发设计所需要考虑的点，文中以一张图展开，围绕着Java类状态，讨论各种情况下的并发安全问题。当理解了Java类的各种变量状态在并发情况下的表现，在写Java多线程代码时就可以做到心中有数，游刃有余，写出更加安全、健壮、灵活的多线程并发代码。
目录
- 1. 多线程并发简介
- 2. 从类状态看Java安全并发
- 3. Java安全并发分解
- 3.1 无状态类
- 3.2 有状态类
- 3.3 私有状态类
- 3.4 共享状态类
- 3.5 不可变状态类（常量状态）
- 3.6 可变状态类
- 3.7 非阻塞设计
- 3.8 阻塞设计
- 3.8.1 资源死锁（resource deadlock）
- 3.8.2 锁顺序死锁（lock-ordering deadlock）
- 3.8.3 状态公开
- 4. 类的静态状态
- 5. 类外部状态和多线程安全并发
- 6. 小结
- 7. 演示代码
- 8. 参考资料
1. 多线程并发简介
在现代操作系统中，CPU的调度都是以线程为基本单位，各个线程各自独立获取到CPU时间片并执行代码指令，这就是多线程并发。于此同时，同一进程中的所有线程将共享当前进程的内存地址空间，这些线程可以访问当前内存地址空间上的同一个变量。若一个线程在使用某个变量时，另一个线程对这个变量进行修改，将造成不可预测的结果，这也是多线程并发问题。
一个简单的例子是，当一个线程循环读取一个数组时，另外一个线程对这个数组内对象进行删除，则前面一个线程可能读取失败或读取的是脏数据。
在多线程并发中，若一段代码的执行不能按预期正确地进行，或者执行的最终结果不可预测，则我们说这段代码并发不安全。换句话说，若线程之间能够按照预期执行代码，操作数据并获取到期望的结果，则实现了安全的并发。
2. 从类状态看Java安全并发
类状态是指类中所声明的变量，无论是公有变量、私有变量，亦或static和final修饰的变量，都是不同形式的类状态。按照Java语法，类变量有如下各种形式，
- 公有变量（public）、私有变量（private）、保护变量（protect）
- 静态变量（static）
- 不可变变量（final）
- 外部变量、内部变量、局部变量
这些类变量在运行时刻，映射到JVM内存中各种对象。Java安全并发设计，其核心在于如何处理这些变量在并发中的表现，掌握它们的特性是Java安全并发设计的关键。
下图从类状态出发，简要的说明了Java类变量的各种状态形式，及其相关的并发安全性，
其中，
- 绿色方块说明多线程并发安全。
- 桔红色方块说明多线程并发不安全，会出现问题。
- 图中的Java类是指完全依据面向对象设计，即：类成员变量被声明为私有，类方法只对类内部成员变量进行操作。
- 有状态是指Java类中有成员变量声明，无论是公有、私有还是保护变量，亦或static和final；无状态则指类中无任何成员变量声明。
- 私有状态是指类成员变量通过ThreadLocal进行了线程隔离，实现了按线程进行变量的分配；而共享状态则指类变量可以被多线程访问。
- 不可变状态是指类成员变量被声明为final，是一种常量状态。
- 静态状态是指类成员变量被声明为static。
- 阻塞是指线程在执行代码前，必须获取锁，这个锁只有一个，通过锁实现了代码的多线程串行执行。
需要注意的是，该图是以Java语言为例来说明如何设计并发安全的对象类，但实践中，图中所涉及的状态、私有状态、不可变状态、非阻塞和阻塞访问，这些概念也应该适用于更多面对对象的编程语言。
下面将对上图中各个类状态进行一一讲解，介绍各个状态下并发设计的要点。
3. Java安全并发分解
3.1 无状态类
一个无状态类是指其没有任何声明的成员变量，例如，
public class StatelessClass {
public void increment() {
int i = 0;
String msg = String.valueOf(i++);
log.info(msg);
}
}
无状态类是线程安全的。上述类中的increment()方法中，有两个本地变量i和msg，这两个本地变量都在方法栈空间上分配，由于栈内存空间是按线程各自独立的，相互隔离，因此栈空间上的变量是线程安全的。
由此还可以知道，在方法调用中分配的变量和对象，若在栈退出后变量或对象引用被JVM释放（不会被外部再访问到），则这个变量和对象也是线程安全的。关于本地变量和JVM栈空间的更多介绍，可以参考这篇文章。
3.2 有状态类
和无状态相反，有状态类是指类中有声明的成员变量，例如
public class StatefulClass {
private int i=0;
public void increment() {
i++;
}
}
上面的类声明了一个int i的类变量，并初始化为0。大多数情况下Java类都是属于有状态类。
有状态是导致线程不安全的必要条件，但它不是充分条件，请继续看下文。
3.3 私有状态类
若Java类的状态通过ThreadLocal等方法，使得状态被隔离在各个线程中，相互不干扰，例如，
public class PrivateStateClass {
private ThreadLocal<Integer> i = new ThreadLocal<>();
public void set(int i) {
i.set(i);
}
public void increment() {
Integer value = i.get();
i.set(value + 1);
}
}
上面的类声明了一个ThreadLocal i的变量，这个类状态按各个线程进行了隔离，为一种私有状态，在执行increment()方法时可以被多线程安全访问。
3.4 共享状态类
正常的Java成员变量是线程共享的，即多个线程通过Java类提供的类方法访问类对象时，类对象中的成员变量可以被共享访问到，这是大多数情况下的应用场景。
共享状态在多线程并发时，不一定就是不安全，其又可以分为常量状态和可变状态两种情况来讨论，请见下文。
3.5 不可变状态类（常量状态）
下面的Java类中，有一个Integer PI变量被声明为final，这说明这个变量是一个常量对象，初始化之后不再改变。
public class FinalStateClass {
private final Integer PI = 3.14;
public double calculate(double radius) {
return PI*radius*radius;
}
}
多线程访问上述的calculate()方法是线程安全的。
final声明使得变量变为常量状态，多线程在访问时不能更改状态，在一定程度上实现了只读，从而是线程安全的。
3.6 可变状态类
对于可变的共享状态，当多线程访问时，必然出现协同操作和同步问题，若代码设计不当，则很容易出现线程不安全问题。
对于可变共享状态的访问，是多线程并发设计时的考虑重点。为了实现线程安全，一般通过下面两种方法，
- 非阻塞设计（多线程并行执行，通过算法实现线程安全）
- 阻塞设计（加锁，使得多线程实现串行执行）
下面是这两种方法的简单比较，
| 非阻塞设计 | 阻塞设计 | |
|---|---|---|
| 多线程执行 | 并行执行 | 串行执行 |
| 安全实现方法 | 通过算法设计 | 通过锁 |
| 吞吐性能 | 高 | 低 |
| 优点 | 无死锁，线程不会被阻塞挂起 | 通过锁可以实现可控的线程调度 |
| 缺点 | 算法实现复杂，在高度竞争情况下，吞吐性能会低于锁 | 线程的挂起和上下文切换、死锁 |
更详细的讨论见下文。
3.7 非阻塞设计
下面的Java类通过原子变量AtomicInteger实现非阻塞的自增算法。
public class AtomicStateClass {
private AtomicInteger i = new AtomicInteger(0);
public void increment() {
i.incrementAndGet();
}
}
可以看到increment()方法没有添加任何锁，但是它可以实现多线程的安全自增操作。AtomicInteger其原理是通过CAS算法，即compareAndSet()方法，先查看变量是否变化，若没有变化则设置值，若有变化，则重新尝试，在绝大数情况下，值的设置在第一次尝试就成功。
更多非阻塞算法设计，比如非阻塞的栈、非阻塞的链表插入操作，见这里。
3.8 阻塞设计
阻塞是指通过锁来控制线程对类状态的访问，使得当前状态只能由一个线程访问，其它访问线程则挂起等待，一直等到锁被释放后，所有的等待线程竞争锁，获得下一次访问权。
锁的设计，使得线程各自之间实现同步，串行执行代码指令，避免了竞争状态。但是于此同时，它也带来了死锁的困扰。若两个线程之间相互持有对方需要的资源或锁，则进入死锁状态。
JVM在解决死锁上没有提供较好的办法机制，更多的是提供监控工具来查看。对于死锁问题，最终解决方案是依赖开发者实现的代码，增加更多的资源，减少锁的碰撞，实现锁的有序持有和不定时释放，都是避免死锁的有效方案。
3.8.1 资源死锁（RESOURCE DEADLOCK）
资源死锁是一种广泛的死锁定义，简单例子是，一个打印任务需要获得打印机和文件对象，若一个线程获得了打印机，而另外一个线程获得了文件对象，相互都不释放获得的资源，则出现资源死锁情况。
增加更多的资源，是解决此类死锁的有效方案。
3.8.2 锁顺序死锁（LOCK-ORDERING DEADLOCK）
下面是一个锁顺序死锁的演示代码，
public class LockOrderingDeadLock {
public void transferMoney(Account from, Account to, Integer amount) {
synchronized (from) {
synchronized (to) {
from.debit(amount);
to.credit(amount);
}
}
}
}
若同时启动两个线程，分别执行下面两个操作，
- 线程1：transferMoney(accountA, accountB, 100)
- 线程2：transferMoney(accountB, accountA, 100)
则很有可能出现死锁状态，因为线程1在握有accountA对象锁的同时，线程2也握有accountB的锁。下面是对transferMoney方法测试过程中，通过JConsole观察到的死锁情况，
图1：pool-1-thread-5握有account@120f74e3的锁，等待account@3e9369b9的锁
图2：pool-1-thread-8握有account@3e9369b9的锁，等待account@120f74e3的锁
解决办法之一，是实现锁的按序持有，即对于任何两个对象锁A和B，先进行排序（排序算法必须是稳定有序），无论是哪个线程，都必须按照锁的排序，依次获取，从而避免相互持有对方需要的锁。
3.8.3 状态公开
状态公开是指类成员变量被公开，在一定程度上破坏了面向对象设计的数据封装性。对类方法再好的阻塞设计，一旦状态被公开，其并发安全性都会功亏一篑。
见下面的例子，类中定义了一个personList的对象，方法insert()和iterate()通过synchronized进行了阻塞加锁，其只能运行一个线程进入类方法执行操作。
public class PublicStateClass {
public ArrayList<String> personList = new ArrayList<>();
public synchronized void insert(String person) {
personList.add(person);
}
public synchronized void iterate() {
Integer size = personList.size();
for (int i = 0; i < size; i++) {
System.out.println(personList.get(i));
}
}
}
但多线程访问insert()和iterate()方法时，并不一定线程安全，主要原因是personList被声明了公开对象，使得类之外的线程可以轻易地访问到personList变量，从而导致personList的状态不一致，在iterate整个person列表时，可能列表中的对象已被删除。
这是类状态公开导致的线程安全问题，究其原因，还要归结于没有做好类的面对对象设计，对外部没有隐藏好数据。
下面的getList方法返回也会导致同样的问题，
public class PublicStateClass {
private ArrayList<String> personList = new ArrayList<>();
public List getList() {
return personList;
}
}
对于这样的问题，推荐的做法是，成员变量声明为私有，在执行读操作时，对外克隆一份数据副本，从而保证类内部数据对象不被泄露，
public class PublicStateClass {
private ArrayList<String> personList = new ArrayList<>();
public List getList() {
return (List) personList.clone();
}
}
4. 类的静态状态
类的静态状态是指类中被static声明的成员变量，这个状态会在类初次加载时初始化，被所有的类对象所共享。Java程序员对这个static关键字应该不会陌生，其使用的场景还是非常广泛，比如一些常量数据，由于没有必要在每个Java对象中存储一份，为了节省内存空间，很多时候声明为static变量。
但static变量并发不安全，从面向对象设计来说，一旦变量声明为静态，则作用空间扩大到整个类域，若被声明为公共变量，则成为全局性的变量，static的变量声明大大破坏了类的状态封装。
为了使静态变量变得多线程并发安全，final声明是它的“咖啡伴侣”。在阿里巴巴的编码规范中，其中一条是，若是static成员变量，必须考虑是否为final。
5. 类外部状态和多线程安全并发
上文在讲并发设计时，都是针对类内部状态，即类内部成员变量被声明为私有，类方法只对类内部变量进行操作，这是一种简化的应用场景，针对的是依据完全面向对象设计的Java类。一种更常见的情况是，类方法需要对外部传入的对象进行操作。这个时候，类的并发设计则和外部状态息息相关。
例如，
public class StatelessClass {
public void iterate(List<Person> personList) {
Integer size = personList.size();
for (int i = 0; i < size; i++) {
System.out.println(personList.get(i));
}
}
}
上面的类是一个无状态类，里面没有任何声明的变量。但是iterate方法接受一个personList的列表对象，由外部传入，personList是一个外部状态。
外部状态类似上文中内部状态公开，无论在类方法上做如何的参数定义（使用ThreadLocal/final进行声明定义），做如何并发安全措施（加锁，使用非阻塞设计），类方法其对状态的操作都是不安全的。外部状态的安全性取决于外部的并发设计。
一个简单的处理方法，在调用类方法的地方，传入一个外部状态的副本，隔离内外部数据的关联性。
6. 小结
类状态的并发，本质上是内存共享数据对象的多线程访问问题。只有对代码中各个Java对象变量的状态特性掌握透彻，写起并发代码时将事倍功半。
下面的类中，整个hasPosition()方法被synchronized修饰，
public class UserLocator {
private final Map<String, String> userLocations = new HashMap<>();
public synchronized boolean hasPositioned(String name, String position) {
String key = String.format("%s.location", name);
String location = userLocations.get(key);
return location != null && position.equals(location);
}
}
但仔细查看可以知道外部变量name和position、内部变量key和location都是并发安全，只有userLocations这个变量存在并发风险，需要加锁保护。因此，将上面的方法进行如下调整，将减少锁的粒度，有效提高并发效率。
public class UserLocator {
private final Map<String, String> userLocations = new HashMap<>();
public boolean hasPositioned(String name, String position) {
String key = String.format("%s.location", name);
String location;
synchronized (this) {
location = userLocations.get(key);
}
return location != null && position.equals(location);
}
}
由此可见，了解类中各个变量特性对写好并发安全代码的重要性。在这个基础上，优化锁的作用范围，减少锁的粒度，实现锁分段，都可以做到信手拈来，游刃有余。
关于类状态，说了这么多，最后给一个全文性总结：面向对象进行类设计，隐藏好数据，控制好类的状态，从严控制变量的访问范围，能private尽量private，能final尽量final，这些都将有助于提高代码的并发健壮性。
7. 演示代码
所有的演示代码在如下的代码仓库中，
8. 参考资料
- 《Java并发编程实战》 [美] Brian Goetz 等 著，童云兰 等 译，ISBN：9787111370048。
- IBM DeveloperWorks：非阻塞算法简介
