想要使用多线程编程,有一个很重要的前提,那就是必须保证操纵的是线程安全的类.

那么如何构建线程安全的类呢? 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引用的逸出)
 
  用高效不可变对象可以简化开发,并由于减少了同步的使用,还会提高性能.

3. 可变对象: 就是可变对象.

下面就是三种对象的发布机制,发布对象的必要条件依赖于对象的可变性:

1. 不可变对象可以通过任意机制发布;
2. 高效不可变对象必须要安全地发布;
3. 可变对象必须要安全发布,同时必须要线程安全或者是被锁保护.

最后一个问题安全发布的对象是否就是线程全的了?

安全发布只能保证对象发布时的可见性,所以要保证线程的安全就要根据对象的可变性,通过同步+安全发布来保证线程安全.

关于同步和线程安全的知识可以看我的上一篇博客
从零开始学多线程之线程安全(一)
这两篇博客的知识点加在一起就可以构建线程安全类了.

在下一篇博客中,我会为大家介绍一些构建线程安全类的模式,这些模式让类更容易成为线程安全的,并且不会让程序意外破坏这些类的线程安全性.

本期分享就到这了,我们下篇再见!
 
 
10-11 08:54