Java多线程 - (一) 最简单的线程安全有关问题
由于很多优秀的Java Web容器或者是J2EE容器的涌现，作为一个java web程序员，很少或者不需要去处理线程的问题，因为服务器或者是框架（如Spring，Struts）等都帮我们处理好了。但当我们查看JDK的API的时候，我们总会看到一些类写着：线程安全或者线程不安全。最简单的例子，比如说StringBuilder这个类中，有这么一句：“将StringBuilder的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用StringBuffer.
为了说明线程的不安全会带来什么问题，下面手动创建一个线程不安全的类，然后在多个线程中去测试使用这个类，看看有什么效果。
/**
*
*/
package com.wsheng.thread.simlesafe;
/**
* 在这个类中的Count方法是计算1一直加到10的和，并输出当前线程名和最后的总和，
* 我们期望的结果应该是每一个线程都会输出55
*
* @author Wang Sheng(Josh)
*
*/
public class Count {
private int num;
// 我们想查看Count类的对象在内存中有几个, 以判断是否有资源共享和竞争
private int objectNum;
public Count(int objectNum) {
this.objectNum = objectNum;
}
public void count() {
for (int i = 1; i <= 10; i++) {
num += i;
}
// Object Number一值都是1，说明只有一个Count对象，保证多个线程共享一个Count对象。
System.out.println(Thread.currentThread().getName() + " : " + num + " Object Number: " + objectNum);
}
}
在这个类中的count方法是计算1一直加到10的和，并输出当前线程名，还有共享的对象(Count)的个数和数字的总和，我们期望的是每个线程都会输出55。
/**
*
*/
package com.wsheng.thread.simlesafe;
/**
* @author Wang Sheng(Josh)
*
*/
public class ThreadTest {
public static void main(String[] args) {
Runnable run = new Runnable() {
int i = 1, j = 1;
// 只会new一次，即10个线程共享1个对象
Count count = new Count(i++);
public void run() {
System.out.println(" ----- Thread running " + j++ + " times");
count.count();
}
};
for (int i = 0; i < 10; i++) {
new Thread(run).start();
}
}
}
这里启动了10个线程，我们先看下输出的结果是不是我们预期的那样
----- Thread running 3 times ----- Thread running 8 times Thread-8 : 110 Object Number: 1 ----- Thread running 10 times Thread-9 : 165 Object Number: 1 ----- Thread running 7 times ----- Thread running 6 times Thread-7 : 275 Object Number: 1 ----- Thread running 5 times ----- Thread running 2 times ----- Thread running 4 times ----- Thread running 1 times Thread-3 : 440 Object Number: 1 Thread-1 : 385 Object Number: 1 Thread-4 : 330 Object Number: 1 Thread-5 : 220 Object Number: 1 ----- Thread running 9 times Thread-2 : 55 Object Number: 1 Thread-6 : 550 Object Number: 1 Thread-0 : 495 Object Number: 1
我们看到只有一个线程（此处是Thread-2)线程输出的结果是我们期望的，而输出的每次都是累加的。为什么都是累加的呢？
根本的原因是我们创建的Count对象是线程共享的，一个线程改变了成员变量num的值，下一个线程正巧读到了修改后的num，所以会递增输出。
要说明线程同步问题首先要说明Java线程的两个特性，可见性和有序性。多个线程之间是不能直接传递数据交互的，它们之间的交互只能通过共享变量来实现。 拿上篇博文中的例子来说明，在多个线程之间共享了Count类的一个对象，这个对象是被创建在主内存(堆内存)中，每个线程都有自己的工作内存(线程 栈)，工作内存存储了主内存Count对象的一个副本，当线程操作Count对象时，首先从主内存复制Count对象到工作内存中，然后执行代码 count.count()，改变了num值，最后用工作内存Count刷新主内存Count。当一个对象在多个内存中都存在副本时，如果一个内存修改了 共享变量，其它线程也应该能够看到被修改后的值，此为可见性。由上述可知，一个运算赋值操作并不是一个原子性操作，多 个线程执行时，CPU对线程的调度是随机的，我们不知道当前程序被执行到哪步就切换到了下一个线程，一个最经典的例子就是银行汇款问题，一个银行账户存款 100，这时一个人从该账户取10元，同时另一个人向该账户汇10元，那么余额应该还是100。那么此时可能发生这种情况，A线程负责取款，B线程负责汇 款，A从主内存读到100，B从主内存读到100，A执行减10操作，并将数据刷新到主内存，这时主内存数据100-10=90，而B内存执行加10操 作，并将数据刷新到主内存，最后主内存数据100+10=110，显然这是一个严重的问题，我们要保证A线程和B线程有序执行，先取款后汇款或者先汇款后 取款，此为有序性。
特别说明： 1. 10个线程，可能一开始都从主内存中读取到count对象的num的值都是1并放到各自的线程栈的工作内存中，但是当线程1执行完并刷新结果到主内存以后，线程2会在进行具体的操作之前，会去清楚自己的工作内存并重新从主内存中读取新的变量num的值。
2. 有序性可以简单的理解为，无论是A线程还是B线程先执行，都要保证有序，即A线程要么先执行完，再执行B线程，或者B线程先执行完，再执行A线程。即要么先取款，或者要么先存款。
如果想要得到我们的期望结果，即每个线程的输出结果都是55.怎么办？有几种解决方案：
1. 将Count类中num变成count方法的局部变量：
/**
*
*/
package com.wsheng.thread.simlesafe;
/**
* 在这个类中的Count方法是计算1一直加到10的和，并输出当前线程名和最后的总和，
* 我们期望的结果应该是每一个线程都会输出55
*
* @author Wang Sheng(Josh)
*
*/
public class Count2 {
// 我们想查看Count类的对象在内存中有几个, 以判断是否有资源共享和竞争
private int objectNum;
public Count2(int objectNum) {
this.objectNum = objectNum;
}
public void count() {
int num = 0;
for (int i = 1; i <= 10; i++) {
num += i;
}
// Object Number一值都是1，说明只有一个Count对象，保证多个线程共享一个Count对象。
System.out.println(Thread.currentThread().getName() + " : " + num + " Object Number: " + objectNum);
}
}
2. 将线程类成员变量拿到run方法中；
/**
*
*/
package com.wsheng.thread.simlesafe;
/**
* @author Wang Sheng(Josh)
*
*/
public class ThreadTest3 {
public static void main(String[] args) {
Runnable run = new Runnable() {
int i = 1, j = 1;
public void run() {
Count count = new Count(i++);
System.out.println(" ----- Thread running " + j++ + " times");
count.count();
}
};
for (int i = 0; i < 10; i++) {
new Thread(run).start();
}
}
}
很明显，这个方法会构造10个Count对象。
3. 每次启动一个线程使用不同的线程类，不推荐。
上述测试，我们发现，存在成员变量的类用于多线程时是不安全的，而变量定义在方法内是线程安全的。想想在使用struts1时，不推荐创建成员变量，因为 action是单例的，如果创建了成员变量，就会存在线程不安全的隐患，而struts2是每一次请求都会创建一个action，就不用考虑线程安全的问 题。