- 编写线程安全的代码,其核心在于要对状态访问操作进行管理,特别是对共享和可变的状态的访问。
- 共享:变量可以由多个线程同时访问;
- 可变:变量的值在其生命周期内可以发生变化(包括变量引用的对象的值的变化);
ps:①类的局部变量是存放在java栈内存上,成员变量是存放在java的堆内存上。而java栈内存是线程私有的,java堆内存是线程共享的。所以要控制类的成员变量;②在java里,类的静态(static)变量也是共享的,所以也要控制。那么java线程安全性是需要控制的是成员变量和静态变量。
可变,如果成员变量或静态变量被 final修饰,该变量被初始化后,变量
值不能再次被赋值,所以该变量是线程安全的。如果一个变量是共享且可变的话,想让其是线程安全的话,必须使用同步机制。
- 如果当多个线程访问同一个可变的状态变量时没有使用合适的同步,那么程序就会出现错误。有三种方式可以修复这个问题:
- 不在线程之间共享该状态变量
- 将状态变量修改为不可变的变量
- 在访问状态变量时使用同步
ps:不在线程之间共享该状态变量,破坏了共享条件;将状态变量修改为不可变的变量,破坏了可变条件;在访问状态变量时使用同步,使用同步机制,所以三个条件,满足其一,即可使线程安全。
- 线程安全性:当多个线程访问某个类时,这个类 始终 都能表现出正确的行为。
ps:因为多线程执行的时候,可能某次因线程执行的顺序关系,造成了程序达到了预期的效果。但并不是每次执行,都能达到程序预期效果。
- 不包含成员变量和静态变量的类,它们实例化的对象成为无状态对象。无状态对象一定是线程安全的。如下面的 Person 类:
public class Person {
public void sayHello() {
System.out.println("Hi, Girl!");
}
}
- 原子操作
Person 类有一个数数方法 count(),每次调用,计数器就会增加1。
public class Person {
private int counter;//计数器
//数数方法
public void count() {
++counter;//每次增加1
try {
Thread.sleep(5);//线程睡眠5毫秒,为演示效果
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//获取计数器的值
public int getCounter() {
return counter;
}
}
下面启了4个线程,每个线程让 person 数10000次,并在线程数完10000次后,输出计数器的值。程序预期应该40000次(4 * 10000)。
public class PersonTest {
public static void main(String[] args) {
final Person person = new Person();
// 人数数,从1数到10000
Runnable runnable = new Runnable() {
public void run() {
for(int i = 0; i < 10000; i++) {
person.count();
}
System.out.println(Thread.currentThread().getName()
+ ",counter=>" + person.getCounter());
}
};
//启动两个线程数数
Thread firThread = new Thread(runnable, "firThread");
Thread secThread = new Thread(runnable, "secThread");
Thread thiThread = new Thread(runnable, "thiThread");
Thread fouThread = new Thread(runnable, "fouThread");
//启动线程
firThread.start();
secThread.start();
thiThread.start();
fouThread.start();
}
}
程序某次运行结果:
thiThread,counter=>39875
fouThread,counter=>39895
firThread,counter=>39895
secThread,counter=>39903
最后结束的线程是 secThread,计数器的值却是 39903,并不是预期的40000。
原因是,Person类非线程安全类。计数器counter是线程共享且可变的。为了让Person类变成线程安全类,可以在count()方法上,增加同步synchronized。
public synchronized void count() {
++counter;
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized int getCounter() {
return counter;
}
再次运行 PersonTest 的 main 方法,程序执行结果:
fouThread,counter=>31884
secThread,counter=>32646
firThread,counter=>39435
thiThread,counter=>40000
程序运行结果与预期一致!
ps:原子操作,指某段代码块在同一时间内,只能有一个线程执行。代码中 ++counter,只有一行,看起来像原子操作,但是实际上并非属于原子操作。
在java中,成员变量是存放在主内存中,每个线程执行的时候,会有一个工作内存(线程私有)。执行 ++counter,其实java做了4步操作:
①从主内存中读取counter的值
②将counter写到加载到工作内存中
③将counter值+1,写到工作内存中
④方法结束后,将counter + 1 的值写到主内存中
当一个线程执行第③步还未执行第④步的时候,第二个线程执行①②操作时,读取的还是counter 没有加上1的值。这个值被称为失效值。
所以 ++counter 不是原子操作。但我们在方法上加了同步(synchronized),每次只有一个线程能调用count()方法,一个线程只有执行完第④步后,第二个线程才能执行,那么每次读取的counter值,都是counter + 1后的值。这样就不会有失效值的问题。