想要使用多线程编程,有一个很重要的前提,那就是必须保证操纵的是线程安全的类.
那么如何构建线程安全的类呢? 1. 使用同步来避免多个线程在同一时间访问同一数据. 2. 正确的共享和安全的发布对象,使多个线程能够安全的访问它们.
那么如何正确的共享和安全的发布对象呢? 这正是这篇博客要告诉你的.
1. 多线程之间的可见性问题.
为什么在多线程条件下需要正确的共享和安全的发布对象呢?
这要说到可见性的问题:
在多线程环境下,不能保证一个线程修改完共享对象的数据,对另一个线程是可见的.
一个线程读到的数据也许是一个过期数据,这会导致严重且混乱的问题,比如意外的异常,脏的数据结构,错误的计算和无限的循环.
举个例子:
public class NoVisibility {
private static int num;
private static boolean ready;
private static class RenderThread extends Thread{
@Override
public void run(){
while(!ready){
Thread.yield();
}
System.out.println("num = " + num);
}
}
public static void main(String [] args) throws InterruptedException {
new RenderThread().start();
num = 42;
ready = true;
}
}
new RenderThread().start()表示创建一个新线程,并执行线程内的run()方法 ,如果ready的值是false,执行Thread.yield()方法(当前线程休息一会让其他线程执行),这时候再交给main方法的主线程执行,给num赋值42,ready赋值true,然后在任务线程中输出num的值.因为可见性的问题,任务线程可能没有看到主线程对num赋值,而输出0.
我们接下来来看看发布对象也会引发的可见性问题.
2. 什么是发布一个对象
发布: 让对象内被当前范围之外的代码所使用.
public class Publish {
public int num1;
private int num2;
public int getNum2(){
return this.num2;
}
}
无论是 publish.num1 还是 publish.getNum2()哪种方法,只要能在类以外的地方获取到对象,我们就称对象被发布了.
如果一个对象在没有完成构造的情况下就发布了,这种情况叫逸出.逸出会导致其他线程看到过期值,危害线程安全.
常见的逸出的情况:
1.最常见的逸出就是将对象的引用放到公共静态域(public static Object obj),发布对象的引用,而在局部方法中实例化这个对象.
public class Test {
public static Set<Object> set;
public void initialize(){
set = new HashSet<>();
}
}
2.发布对象的状态,而且状态是可变的(没用final修饰),或状态里包含其他的可变数据.
public class UnsafeStates {
private String [] states = new String[]{"a","b","c"};
public String[] getStates(){
return states;
}
}
3.在构造方法中使用内部类. 内部类的实例包含了对封装实隐含的引用.
public class UnsafeStates {
private Runnable r;
public UnsafeStates() {
r = new Runnable() {
@Override
public void run() {
// 内部类在对象没有构造好的情况下,已经可以this引用,逸出了
// do something;
}
};
}
}
逸出主要会导致两个方面的问题:
1. 发布线程以外的任何线程都能看到对象的域的过期值,因而看到的是一个null引用或者旧值,即使此刻对象已经被赋予了新值.
2. 线程看到对象的引用是最新的,但是对象的状态却是过期的.
我们已经了解了逸出的问题,那么如何安全的发布一个对象呢?
为了安全地发布对象,对象的引用以及对象的状态必须同时对其他线程可见(也就是说安全发布就是保证对象的可见性),一个正确创建的对象可以通过下列条件安全发布:
1. 通过静态初始化器初始化对象的引用.
public class NoVisibility {
public static Object obj = new Object();
}
2. 将它的引用存储到volatile域或AtomicReference;
public class NoVisibility {
public volatile Object obj = new Object();
}
Volatile可以保证可见性.性能消耗也只比非volatile多一点,但是不要过度依赖volatile变量,它比使用锁的代码更脆弱,更难以理解,
使用volatile的最佳方式就是用它来做退出循环的条件.
使用volatile的例子:
public class Cycle {
private boolean condition;
public void loop(){
while (condition){
//do something..
}
}
public void changeCondition(){
if(condition == true){
condition = false;
}else{
condition = true;
}
}
}
3. 将它的引用储存到正确创建的对象的final域中.
public class NoVisibility {
public final Object obj = new Object();
}
4. 或者将它的引用存储到由锁正确保存的域中.
public class NoVisibility {
private Hashtable<String,Object> hashtable = new Hashtable<>();
public void setHashtable(){
Object obj = new Object();
hashtable.put("obj",obj);
}
}
不限于HashTable,只要是线程安全的容器都行
现在我们了解了如何安全的发布一个对象,那么
问题来了,是否所有对象都需要安全发布?安全发布的对象是否就是线程全的了?
让我们继续往下看.
3.如何构建一个线程安全的类.
我们先来回答上面的第一个疑问,是否所有对象都需要安全发布?
答案都是否定的.
要回答这个问题,我们先简单了解一下以下的三种对象:
1.不可变对象
2.高效不可变对象
3.可变对象
1.不可变对象:创建后不能被修改的对象叫不可变对象,不可变对象天生是线程安全的.
不可变对象不仅仅是所有域都是final类型的,
只有满足如下状态才是不可变对象:
1.1
它的状态不能在创建后改变.(包括状态包含的其他值也不可做修改,比如状态是一个集合list,list里面的值也不可以修改,或者状态是一个对象,那么对象的状态也不更改)
1.2.所有域都是final类型的.
1.3.它被正确创建(创建期间没有this引用的逸出)
2.不可变对象: 技术上是可以改变的,但是实际应用程序中,不会被改变
用高效不可变对象可以简化开发,并由于减少了同步的使用,还会提高性能.
3. 可变对象: 就是可变对象.
下面就是三种对象的发布机制,发布对象的必要条件依赖于对象的可变性:
1. 不可变对象可以通过任意机制发布;
2. 高效不可变对象必须要安全地发布;
3. 可变对象必须要安全发布,同时必须要线程安全或者是被锁保护.
最后一个问题安全发布的对象是否就是线程全的了?
安全发布只能保证对象发布时的可见性,所以要保证线程的安全就要根据对象的可变性,通过同步+安全发布来保证线程安全.
关于同步和线程安全的知识可以看我的上一篇博客
从零开始学多线程之线程安全(一)
这两篇博客的知识点加在一起就可以构建线程安全类了.
在下一篇博客中,我会为大家介绍一些构建线程安全类的模式,这些模式让类更容易成为线程安全的,并且不会让程序意外破坏这些类的线程安全性.
本期分享就到这了,我们下篇再见!