什么是线程安全?怎么样才能做到线程安全?
什么是线程安全?
当多个线程访问某个类时,不管运行时环境采用何种调度方式或者这些线程将如何交替执行,并且在调用代码中不需要任何额外的同步或者协同,这个类都能表现出正确的行为,那么就称这个类是线程安全的。
怎么样才能做到线程安全?
解决线程安全的方案:
1.基于JVM的锁
无法解决分布式情况的问题
2.基于数据库的锁(分布式)
耗费资源
3.基于redis的锁(分布式)
可能会出现死锁
4.基于zookeeper的锁(分布式)
最优级
实现好的并发是一件困难的事情,所以很多时候我们都想躲避并发。从下面几点可以避免并发:
-
线程封闭
-
无状态的类
- 让类不可变
- volatile
- 加锁和CAS
- 安全的发布
- ThreadLocal
线程封闭
什么是线程封闭?
就是把对象封装到一个线程里,只有这一个线程能看到此对象。那么这个对象就算不是线程安全的也不会出现任何安全问题。
实现线程封闭有哪些方法?
ad-hoc 线程封闭
这是完全靠实现者控制的线程封闭,他的线程封闭完全靠实现者实现。
Ad-hoc 线程封闭非常脆弱,应该尽量避免使用。
栈封闭
栈封闭是我们编程当中遇到的最多的线程封闭。
什么是栈封闭呢?
简单的说就是局部变量。
多个线程访问一个方法,此方法中的局部变量都会被拷贝一份到线程栈中。所以局部变量是不被多个线程所共享的,也就不会出现并发问题。所以能用局部变量就别用全局的变量,全局变量容易引起并发问题。
无状态的类
没有任何成员变量的类,就叫无状态的类,这种类一定是线程安全的。
无状态就是一次操作,不能保存数据。无状态对象(Stateless Bean),就是没有实例变量的对象.不能保存数据,是不变类。
如果这个类的方法参数中使用了对象,也是线程安全的吗?比如:
让类不可变
让状态不可变,两种方式:
1,加 final 关键字,对于一个类,所有的成员变量应该是私有的,同样的只要有可能,所有的成员变量应该加上 final 关键字,但是加上 final,要注意如果成员变量又是一个对象时,这个对象所对应的类也要是不可变,才能保证整个类是不可变的。
参见代码
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; } } }
2、根本就不提供任何可供修改成员变量的地方,同时成员变量也不作为方法的返回值。
参见代码
public class ImmutableClassToo { private final List<Integer> list = new ArrayList<Integer>(3); public ImmutableClassToo() { list.add(1); list.add(2); list.add(3); } public boolean isContain(int i){ return list.contains(i); } }
但是要注意,一旦类的成员变量中有对象,上述的 final 关键字保证不可变并不能保证类的安全性,为何?因为在多线程下,虽然对象的引用不可变,但是对象在堆上的实例是有可能被多个线程同时修改的,没有正确处理的情况下,对象实例在堆中的数据是不可预知的。这就牵涉到了如何安全的发布对象这个问题。
volatile
加锁和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<Integer>(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 发布出去后,是可以被外部线程之间修改,那么在多个线程同时修改的情况下不安全问题是肯定存在的,怎么修正这个问题呢?
我们在发布这对象出去的时候,就应该用线程安全的方式包装这个对象。
参见代码
/** * 安全的发布 */ public class SafePublishToo { private List<Integer> list = Collections.synchronizedList(new ArrayList<Integer>(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,就都是线程安全的了。
private List<Integer> list = Collections.synchronizedList(new ArrayList<Integer>(3));
对于我们自己使用或者声明的类,JDK 自然没有提供这种包装类的办法,但是我们可以仿造这种模式或者委托给线程安全的类,当然,对这种通过 get 等方法发布出去的对象,最根本的解决办法还是应该在实现上就考虑到线程安全问题。
参见以上代码 ↑↑↑
ThreadLocal
ThreadLocal 是实现线程封闭的最好方法。
ThreadLocal 内部维护了一个 Map,Map 的 key 是每个线程的名称,而 Map 的值就是我们要封闭的对象。每个线程中的对象都对应着 Map 中一个值,也就是 ThreadLocal 利用 Map 实现了对象的线程封闭。