什么是线程安全性
在《Java 并发编程实战》中,定义如下:
当多个线程访问某个类时,不管运行时环境采用何种调度方式或者这些线程将如何交替执行,并且在调用代码中不需要任何额外的同步或者协同,这个类都能表现出正确的行为,那么就称这个类是线程安全的。
线程封闭
实现好的并发是一件困难的事情,所以很多时候我们都想躲避并发。避免并发最简单的方法就是线程封闭。什么是线程封闭呢?
就是把对象封装到一个线程里,只有这一个线程能看到此对象。那么这个对象就算不是线程安全的也不会出现任何安全问题。实现线程封闭有哪些方法呢?
ad-hoc线程封闭
这是完全靠实现者控制的线程封闭,他的线程封闭完全靠实现者实现。 Ad-hoc 线程封闭非常脆弱,应该尽量避免使用。
栈封闭
栈封闭是我们编程当中遇到的最多的线程封闭。
什么是栈封闭呢?
简单的说 就是局部变量。多个线程访问一个方法,此方法中的局部变量都会被拷贝一份到 线程栈中。所以局部变量是不被多个线程所共享的,也就不会出现并发问题。所以能用局部变量就别用全局的变量,全局变量容易引起并发问题。
无状态的类
没有任何成员变量的类,就叫无状态的类,这种类一定是线程安全的。
参见代码:
/**
1. 无状态的类
*/
public class StatelessClass {
public int service(int a,int b){
return a+b;
}
public void serviceUser(UserVo user){
//do sth user
}
}
如果这个类的方法参数中使用了对象,也是线程安全的吗?比如:
当然也是,为何?因为多线程下的使用,固然 user 这个对象的实例会不正 常,但是对于 StatelessClass 这个类的对象实例来说,它并不持有 UserVo 的对象 实例,它自己并不会有问题,有问题的是 UserVo 这个类,而非 StatelessClass 本身。
让类不可变
让状态不可变,两种方式:
- 加 final 关键字,对于一个类,所有的成员变量应该是私有的,同样的只 要有可能,所有的成员变量应该加上 final 关键字,但是加上 final,要注意如果 成员变量又是一个对象时,这个对象所对应的类也要是不可变,才能保证整个类 是不可变的。
参见代码:
/**
1. 类不可变
*/
public class ImmutableClass {
private final int a;
private final UserVo user = new UserVo();//不安全
public int getA() {
return a;
}
public UserVo getUser() {
return user;
}
public ImmutableClass(int a) {
this.a = a;
}
public static class User{
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
}
- 根本就不提供任何可供修改成员变量的地方,同时成员变量也不作为方 法的返回值。
参见代码:
/**
* 类不可变--事实不可变
*/
public class ImmutableClassToo {
private final List<Integer> list = new ArrayList<>(3);
public ImmutableClassToo() {
list.add(1);
list.add(2);
list.add(3);
}
public boolean isContain(int i){
return list.contains(i);
}
}
但是要注意,一旦类的成员变量中有对象,上述的 final 关键字保证不可变并不能保证类的安全性,为何?
因为在多线程下,虽然对象的引用不可变,但是 对象在堆上的实例是有可能被多个线程同时修改的,没有正确处理的情况下,对 象实例在堆中的数据是不可预知的。这就牵涉到了如何安全的发布对象这个问题。
volatile
并不能保证类的线程安全性,只能保证类的可见性,最适合一个线程写,多个线程读的情景。
加锁和CAS
我们最常使用的保证线程安全的手段,使用 synchronized 关键字,使用显式 锁,使用各种原子变量,修改数据时使用 CAS 机制等等。
安全的发布
类中持有的成员变量,如果是基本类型,发布出去,并没有关系,因为发布 出去的其实是这个变量的一个副本
参见代码:
/**
* 演示基本类型的发布
*/
public class SafePublish {
private int i;
public SafePublish() {
i = 2;
}
public int getI() {
return i;
}
public static void main(String[] args) {
SafePublish safePublish = new SafePublish();
int j = safePublish.getI();
System.out.println("before j="+j);
j = 3;
System.out.println("after j="+j);
System.out.println("getI = "+safePublish.getI());
}
}
但是如果类中持有的成员变量是对象的引用,如果这个成员对象不是线程安 全的,通过 get 等方法发布出去,会造成这个成员对象本身持有的数据在多线程 下不正确的修改,从而造成整个类线程不安全的问题。
参见代码
/**
* 不安全的发布
*/
public class UnSafePublish {
private List<Integer> list = new ArrayList<>(3);
public UnSafePublish() {
list.add(1);
list.add(2);
list.add(3);
}
public List getList() {
return list;
}
public static void main(String[] args) {
UnSafePublish unSafePublish = new UnSafePublish();
List<Integer> list = unSafePublish.getList();
System.out.println(list);
list.add(4);
System.out.println(list);
System.out.println(unSafePublish.getList());
}
}
这个 list 发布出去后,是可以被外部线程之间修改,那么在多个线程同时修 改的情况下不安全问题是肯定存在的,怎么修正这个问题呢?我们在发布这对象 出去的时候,就应该用线程安全的方式包装这个对象。
参见代码:
/**
1. 安全的发布
*/
public class SafePublishToo {
private List<Integer> list
= Collections.synchronizedList(new ArrayList<>(3));
public SafePublishToo() {
list.add(1);
list.add(2);
list.add(3);
}
public List getList() {
return list;
}
public static void main(String[] args) {
SafePublishToo safePublishToo = new SafePublishToo();
List<Integer> list = safePublishToo.getList();
System.out.println(list);
list.add(4);
System.out.println(list);
System.out.println(safePublishToo.getList());
}
}
我们将 list 用 Collections.synchronizedList 进行包装以后,无论多少线程使用这个 list,就都是线 程安全的了。
对于我们自己使用或者声明的类,JDK 自然没有提供这种包装类的办法,但 是我们可以仿造这种模式或者委托给线程安全的类,当然,对这种通过 get 等方 法发布出去的对象,最根本的解决办法还是应该在实现上就考虑到线程安全问题
另外对容器的包装
/**
* 仿Collections对容器的包装,将内部成员对象进行线程安全包装
*/
public class SoftPublicUser {
private final UserVo user;
public UserVo getUser() {
return user;
}
public SoftPublicUser(UserVo user) {
this.user = new SynUser(user);
}
private static class SynUser extends UserVo{
private final UserVo userVo;
private final Object lock = new Object();
public SynUser(UserVo userVo) {
this.userVo = userVo;
}
@Override
public int getAge() {
synchronized (lock){
return userVo.getAge();
}
}
@Override
public void setAge(int age) {
synchronized (lock){
userVo.setAge(age);
}
}
}
}
/**
* 类说明:委托给线程安全的类来做
*/
public class SafePublicFinalUser {
private final SynFinalUser user;
public SynFinalUser getUser() {
return user;
}
public SafePublicFinalUser(FinalUserVo user) {
this.user = new SynFinalUser(user);
}
public static class SynFinalUser{
private final FinalUserVo userVo;
private final Object lock = new Object();
public SynFinalUser(FinalUserVo userVo) {
this.userVo = userVo;
}
public int getAge() {
synchronized (lock){
return userVo.getAge();
}
}
public void setAge(int age) {
synchronized (lock){
userVo.setAge(age);
}
}
}
}
TheadLocal
ThreadLocal 是实现线程封闭的最好方法。 ThreadLocal 内部维护了一个 Map, Map 的 key 是每个线程的名称,而 Map 的值就是我们要封闭的对象。每个线程 中的对象都对应着 Map 中一个值,也就是 ThreadLocal 利用 Map 实现了对象的线程封闭。
Servlet辨析
不是线程安全的类,为什么我们平时没感觉到:
- 在需求上,很少有共享的需求
- 接收到了请求,返回应答的时候,一 般都是由一个线程来负责的。 但是只要 Servlet 中有成员变量,一旦有多线程下的写,就很容易产生线程安全问题。