Java并发编程笔记2-线程可见性&线程封闭&指令重排序

  1. 云栖社区>
  2. 博客>
  3. 正文

Java并发编程笔记2-线程可见性&线程封闭&指令重排序

狂小白 2018-03-05 17:38:00 浏览678
展开阅读全文

一.指令重排序

例子如下:

public class Visibility1 {
    public static boolean ready;
    public static int number;
}
public class ReaderThread extends Thread {

    @Override
    public void run() {
        while (!Visibility1.ready){
            Thread.yield();
            System.out.println(Visibility1.number);
        }
    }
}
public class Test1 {
    public static void main(String[] args) {
        new ReaderThread().start();
        Visibility1.number = 42;
        Visibility1.ready = true;
    }
}

多次运行结果分别如下:

可以看到多次运行所得到三种结果,分别为0,42,没有输出结果。

程序一开始执行,默认将ready赋值为false,ready默认赋值为0,一开始执行时,在ReaderThread中符合循环条件,进入循环,遇到

Thread.yield();
这语句是就是说当一个线程使用了这个方法之后,它就会把自己CPU执行的时间让掉,让自己或者其它的线程运行。如果自己先走出现结果为0的情况,因为,默认初始int的类型数据为0,如果让别的线程先走让这样就又回到了Main方法中的继续执行
Visibility1.number = 42;
Visibility1.ready = true;
这两条语句,问题来了,这两条语句会按照程序的顺序执行吗?
答案是,并不一定的。这就涉及到指令重排序问题,也就是说

CPU一般采用流水线来执行指令。一个指令的执行被分成:取指、译码、访存、执行、写回、等若干个阶段。然后,多条指令可以同时存在于流水线中,同时被执行。

指令流水线并不是串行的,并不会因为一个耗时很长的指令在“执行”阶段呆很长时间,而导致后续的指令都卡在“执行”之前的阶段上。

重排序的目的是为了性能。

也就是说,有时候CPU认为

Visibility1.ready = true; 语句执行要快,所以让Visibility1.ready = true;先执行。这就导致了会出现了无输出结果。这就是涉及了指令重排序问题,虽然这里如果出现了指令重排序问题,
进入生产开发会造成严重的后果的。
但是要注意一点,如下:

 

二.可见性

可见性,是指线程之间的可见性,一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。比如:用volatile修饰的变量,就会具有可见性。volatile修饰的变量不允许线程内部缓存和重排序,即直接修改内存。

所以对其他线程是可见的。但是这里需要注意一个问题,volatile只能让被他修饰内容具有可见性,但不能保证它具有原子性。比如 volatile int a = 0;之后有一个操作 a++;这个变量a具有可见性,但是a++ 依然是一个非原子操作,也就这这个操作同样存在线程安全问题。

先看如下程序:

public class Visibility {
    private static boolean bChanged;

    public static void main(String[] args) throws InterruptedException {
        new Thread(){
            @Override
            public void run() {
                for (; ; ){
                    if (bChanged == true){
                        System.out.println("!=");
                        System.exit(0);
                    }
                }
            }
        }.start();
        Thread.sleep(10);

        new Thread(){
            @Override
            public void run() {
                for (; ; ){
                    bChanged = true;
                }
            }
        }.start();
    }

}

运行结果为:


可以看到运行为死循环。按道理来说应该会输出!=结束的。但是为什么会出现死循环呢?
原因是因为程序中bChanged如果没有手动赋值前,默认是false的,所以一开始没输出,但是第二线程命名修改了bChanged的值了,为什么还不退出呢,因为线程是CPU启动的,而CPU一开始从主存中取数据并没有立即将数据送到CPU,而是先送到了缓存中,
而,另外一个线程修改bChanged的值,是就该主存中的值,而那个输出结果的线程并没有从主存中取bChanged的值,而是去缓存中取了bChanged的值,而缓存中bChanged的值是false,这就是为什么会死循环的原因。如下图:


解决办法:
  1.在成员变量中加入关键字volatile,如下:
  
private volatile static boolean bChanged;


这个关键字告诉线程一定要走内存,不要再从缓存中获取数据了。只要已修改,其他线程立马知道值已经被修改了,因为它们都是从主存中取的数据。
修改后的结果如下图:

可以看到程序立马结束。并且有输出。因为这个关键字让这个成员变量都可见了。这就是线程的可见性。

其实volatile关键字还有一个功能就是:阻止指令排序。但是这只是相对的阻止。如下:

以前官方推荐是volatile,但是现在synchronized已经优化的很好了。不要刻意去用volatile。如果一个类加上volatile关键字,那么它的成员变量也会默认加上volatile关键字。

volatile只能解决可见性。一定程度上解决指令排序,但是是相对的。

但是volatile解决了可见性,就一定可以解决问题了吗?并不是的。例子如下:

如果你只希望单一变量可见性,volatile是可以的,但是如果关注的不是单一变量volatile就不管用了。

2.用synchronize加锁的办法。它能解决可见性,原子性。

 

三.线程封闭

实现好的并发是一件困难的事情,所以很多时候我们都想躲避并发。避免并发最简单的方法就是线程封闭。什么是线程封闭呢?

当访问共享变量时,往往需要加锁来保证数据同步。一种避免使用同步的方式就是不共享数据。如果仅在单线程中访问数据,就不需要同步了。这种技术称为线程封闭。在Java语言中,提供了一些类库和机制来维护线程的封闭性,例如局部变量和ThreadLocal类,

线程封闭其实就是不共享数据就行了。

线程封闭方法有:

  1.不要共享变量,在变量中加final关键字

  2.栈封闭:栈封闭是我们编程当中遇到的最多的线程封闭。什么是栈封闭呢?简单的说就是局部变量。多个线程访问一个方法,此方法中的
局部变量都会被拷贝一分儿到线程栈中。所以局部变量是不被多个线程所共享的,也就不会出现并发问题。所以能用局部变量就别用全局的变量,全局变量容易引起并发问题。如果了解JVM应该懂得。

  3.ThreadLocal线程绑定。ThreadLocal内部维护了一个Map,Map的key是每个线程的名称,而Map的值就是我们要封闭的对象。每个线程中的对象都对应着Map中一个值,也就是ThreadLocal利用Map实现了对象的线程封闭。

想要操作什么数据,可以先把数据放在ThreadLocal中绑定,用的时候才取出来。

例子如下:

public class LocalTest {
    private int num;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}
public class ThreadLocalDemo {
    private static ThreadLocal<LocalTest> threadLocal = new ThreadLocal<LocalTest>();

    public static void main(String[] args) throws InterruptedException{
         final LocalTest local = new LocalTest();

        new Thread(){
            @Override
            public void run() {
                for (; ; ){
                    threadLocal.set(local);
                    LocalTest l = threadLocal.get();
                    l.setNum(20);
                    System.out.println(Thread.currentThread().getName() + "---" +threadLocal.get().getNum());
                    Thread.yield();
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                for (; ; ){
                    threadLocal.set(local);
                    LocalTest l = threadLocal.get();
                    l.setNum(30);
                    System.out.println(Thread.currentThread().getName() + "---" +threadLocal.get().getNum());
                    Thread.yield();
                }
            }
        }.start();

    }

}

结果如下:

 

可以看到各个线程对应的值并没有乱。

网友评论

登录后评论
0/500
评论
狂小白
+ 关注