并发编程学习笔记之可见性&过期数据(二)

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

那么如何构建线程安全的类呢? 1. 使用同步来避免多个线程在同一时间访问同一数据. 2. 正确的共享和安全的发布对象,使多个线程能够安全的访问它们.

那么如何正确的共享和安全的发布对象呢? 这正是这篇博客要告诉你的.

1. 多线程之间的可见性问题.

为什么在多线程条件下需要正确的共享和安全的发布对象呢?

这要说到可见性的问题:

在多线程环境下,不能保证一个线程修改完共享对象的数据,对另一个线程是可见的.

一个线程读到的数据也许是一个过期数据,这会导致严重且混乱的问题,比如意外的异常,脏的数据结构,错误的计算和无限的循环.

举个例子:

    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. 可变对象必须要安全发布,同时必须要线程安全或者是被锁保护.

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

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

关于同步和线程安全的知识可以看我的上一篇博客从零开始学多线程之线程安全(一)

这两篇博客的知识点加在一起就可以构建线程安全类了.

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

本期分享就到这了,我们下篇再见!