目录
- 一、线程
- 二、线程不安全产生的原因
- 三、确保线程安全的方法
- 1.限制数据共享
- 2.不可变性
- 3.使用线程安全的数据类型
- 4.锁与同步
一、线程
并发模块有两种类型：进程(Process)与线程(Thread)。一个进程表示一个虚拟计算机，一个线程表示一个虚拟CPU，线程之间共享内存，可以互相通信。
Java中提供了Thread类，继承Runnable接口。Thread类可以如下使用：
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello from thread 1");
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello from thread 2");
}
});
thread1.start();
thread2.start();向构造方法中提供一个Runnable接口的具体实现，在run()方法中写进程中执行的代码，并调用start()方法执行线程。
此外，也可以显式地指定线程名：
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello from thread 1");
}
},"thread1");还可以用自定义的类继承Thread类：
public class MyThread extends Thread{
@Override
public void run() {
System.out.println("my thread");
}
}覆写run()方法并调用start()方法执行进程。
二、线程不安全产生的原因
我们来看一个产生线程不安全的例子：
public class Count{
private int count = 0;
private void add() throws InterruptedException {
int c = count + 1;
Thread.sleep(1);
count = c;
}
public void test(int n){
for(int i = 0; i < n; i++){
new Thread(new Runnable() {
@Override
public void run() {
try {
add();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
public int getCount(){
return count;
}
}这段代码中，add()方法每次给count值加一，test()方法中通过n个线程调用n次add()方法，那么，count的值将变为n。然而事实真的如此吗？我们来测试一下：
public class Main {
public static void main(String[] args) throws InterruptedException {
Count c = new Count();
c.test(10);
Thread.sleep(20);//等待子线程执行完毕
System.out.println(c.getCount());
}
}多次测试，得到了一些不同结果，笔者进行五次测试分别得到2，1，2，1，1的输出。
产生的输出不是我们预期的10，原因在于各个线程之间的竞争。我们的CPU的一个核对于多线程的处理并非是绝对意义上的并行，即同一时间执行多项任务，而是通过时间分片的方式实现：
具体来说，在一个双线程的程序中，CPU可以先处理线程1的某一部分将其挂起处理线程2的某一部分，再将线程2挂起继续处理线程1。同一时刻上CPU至多处理一个线程。并且，CPU在进程间转换的行为在程序员的视角是不可预测的。
再具体到我们的例子，子线程在CPU的核上执行到sleep()方法时会被挂起，以让出资源执行其他线程。假如有两个线程A、B，A线程执行完c = count + 1语句，得到c = 1，此时count的值并未被改变。此时执行线程B，B线程执行执行c = count + 1语句，同样得到c = 1。因此就会产生线程不安全的因素。
那么有人可能会问，如果add()方法中不执行sleep()，而写成
private void add() {
count++;
}会产生线程不安全吗？事实上，count++虽然在Java中体现为一句，但Java语句不能被CPU直接执行，需要编译成机器指令。CPU所能执行的单条指令我们称为原子指令，简单的把变量自身+1对应三条原子指令：
- 从内存中取出count值放入寄存器中；
- 寄存器中值+1；
- 将寄存器中值写回内存；
CPU核同样可以在某条原子语句后切换线程。线程不安全的根本原因在于，我们无法预测CPU在哪条原子语句后切换线程。例如我们运行test(2)。有两个线程A、B，假定CPU先执行A的1、2，挂起A；执行B的1、2，挂起B；此时A、B线程中寄存器的值均为1，CPU将其再写回内存，count值就变成了1而非我们希望得到的2。
三、确保线程安全的方法
线程安全指的是数据类型或是方法在多线程中无论有多少处理器、OS如何调度线程，不要求调用者满足某种线程安全的义务的情况下均能正确地执行。
实现线程安全有四种方法：
1.限制数据共享
将可变数据限制在线程内部以避免竞争，并且不允许任何线程直接对其进行读写操作。核心思想：线程之间不共享可变(mutable)数据类型。如果一个ADT的rep中包含 mutable的属性且多线程之间 对其进行mutator操作，那么 就很难使用confinement策略 来确保该ADT是线程安全的。
2.不可变性
使用不可变数据类型和不可变引用，避免多线程之间的竞争情况。 不可变数据通常是线程安全的。
3.使用线程安全的数据类型
如果必须要用mutable的数据类型在多线程之间共享数据，要使用线程安全的数据类型。 在JDK中的类，文档中明确指明了是否线程安全。一般来说， JDK同时提供两个相同功能的类，一个是线程安全的，另一个不是，原因在于，线程安全的类一般性能上受影响 。例如StringBuffer类与StringBuilder类
集合类，如List,Map,Set都是线程不安全的。可以使用线程安全的版本替代：
private static Map<Integer,Boolean> cache = Collections.synchronizedMap(new HashMap<>());但在线程安全的集合类中，执行其上某个操作是threadsafe的，但如果多个操作放在一起，仍旧不安全。例如：
if ( !lst.isEmpty()) {
String s = lst.get(0);
...
}仍可能产生线程间的干扰。例如线程A中执行上述代码，判断lst为空后被CPU挂起，CPU执行线程B，清空了lst。这时再返回线程A就会产生异常。
此外，使用iterator或是循环遍历也是不安全的，应当按需要进行加锁。
4.锁与同步
当我们不得不在多线程间共享mutable类型的数据时，就要用到锁机制，使某个线程获得对数据的独家修改权，其他线程被阻塞，不得访问。
Java中提供了synchronized关键字，可以锁定某对象，使得该对象只能被一个进程独占。例：
/**
* 同步线程
*/
class SyncThread implements Runnable {
private static int count;
public SyncThread() {
count = 0;
}
public void run() {
synchronized(this) {
for (int i = 0; i < 5; i++) {
try {
System.out.println(Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public int getCount() {
return count;
}
}如下调用：
SyncThread syncThread = new SyncThread();
Thread thread1 = new Thread(syncThread, "SyncThread1");
Thread thread2 = new Thread(syncThread, "SyncThread2");
thread1.start();
thread2.start();得到结果
SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread1:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread2:7
SyncThread2:8
SyncThread2:9回到我们在上文所举的线程不安全的例子，我们同样可以用synchronized关键字修饰：
public class Count{
private int count = 0;
private synchronized void add() throws InterruptedException {
int c = count + 1;
Thread.sleep(1);
count = c;
}
public void test(int n){
for(int i = 0; i < n; i++){
new Thread(new Runnable() {
@Override
public void run() {
try {
add();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
public int getCount(){
return count;
}
}public class Main {
public static void main(String[] args) throws InterruptedException {
Count c = new Count();
c.test(10);
Thread.sleep(20);//等待子线程执行完毕
System.out.println(c.getCount());
}
}得到预期的输出10。
synchronized关键字修饰instance方法时，以下两种用法是等价的：
public synchronized void myMethod(){
//some code
}public void myMethod(){
synchronized (this) {
//some code
}
}修饰static方法时如下两种用法等价：
public class MyClass(){
public synchronized static void myStaticMethod(){
//some code
}
}public class MyClass(){
public static void myStaticMethod(){
synchronized (MyClass.class) {
//some codeM
}M
}
}我们有时不希望对整个对象加锁，例如线程A访问加锁的方法a时我们希望线程B能正常访问方法b，此时我们也有对应的办法实现特定代码段的加锁：
public class MyClass(){
Object lock = new Object();
public void methodA(){
//some code
synchronized (lock){
//some code
}
//some code
}
public void methodB(){
//some code
}
}通常而言，对所有ADT的rep访问都需要加锁。需要注意的是，这种方法会显著地影响程序运行效率。也正因此，Java提供的mutable类大部分都是线程不安全的。
