亲宝软件园·资讯

展开

java多线程3:原子性,可见性,有序性

16bit 人气:2

概念

  在了解线程安全问题之前,必须先知道为什么需要并发,并发给我们带来什么问题。

       为什么需要并发,多线程?

  1. 时代的召唤,为了更充分的利用多核CPU的计算能力,多个线程程序可通过提高处理器的资源利用率来提升程序性能。
  2. 方便业务拆分,异步处理业务,提高应用性能。

   多线程并发产生的问题?

  1. 大量的线程让CPU频繁上下文切换带来的系统开销。
  2. 临界资源线程安全问题(共享,可变)。
  3. 容易造成死锁。

注意:当多个线程执行一个方法时,该方法内部的局部变量并不是临界资源,因为这些局部变量是在每个线程的私有栈中,因此不具有共享性质,不会导致线程安全问题。

可见性

 多线程访问同一个变量时,如果有一个线程修改了这个变量的值,其他线程能够立即看得到修改的值。这是因为为了保证多个CPU之间的高速缓存是一致的,操作系统会有一个缓存一致性协议,volatile就是通过OS的缓存一致性协议策略来保证了共享变量在多个线程之间的可见性。

public class ThreadDemo2 {

    private static boolean flag = false;

    public void thread_1(){
        flag = true;
        System.out.println("线程1已对flag做出改变");
    }

    public void thread_2(){
        while (!flag){
        }
        System.out.println("线程2->flag已被修改,成功打断循环");
    }

    public static void main(String[] args) {
        ThreadDemo2 threadDemo2 = new ThreadDemo2();
        Thread thread2 = new Thread(()->{
            threadDemo2.thread_2();
        });
        Thread thread1= new Thread(()->{
            threadDemo2.thread_1();
        });
        thread2.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread1.start();
    }
}

执行结果

线程1已对flag做出改变

代码无论执行多少次,线程2的输出语句都不会被打印。为flag添加volatile修饰后执行,线程2执行的语句被打印

执行结果

线程1已对flag做出改变
线程2->flag已被修改,成功打断循环

局限:volatile只是保证共享变量的可见性,无法保证其原子性。多个线程并发时,执行共享变量i的i++操作<==> i = i + 1,这是分两步执行,并不是一个原子性操作。根据缓存一致性协议,多个线程读取i并对i进行改变时,其中一个线程抢先独占i进行修改,会通知其他CPU我已经对i进行修改,把你们高速缓存的值设为无效并重新读取,在并发情况下是可能出现数据丢失的情况的。

public class ThreadDemo3 {
    private volatile static int count = 0;
    public static void main(String[] args) {
        for (int i = 0; i < 10; ++i){
            Thread thread = new Thread(()->{
                for (int j = 0; j < 1000; ++j){
                    count++;
                }
            });
            thread.start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("count执行的结果为->" + count);
    }
}

执行结果

count执行的结果为->9561

注意:这个结果是不固定的,有时10000,有时少于10000。

原子性

就像恋人一样同生共死,表现在多线程代码中程序一旦开始执行,就不会被其他线程干扰要嘛一起成功,要嘛一起失败,一个操作不可被中断。在上文的例子中,为什么执行结果不一定等于10000,就是因为在count++是多个操作,1.读取count值,2.对count进行加1操作,3.计算的结果再赋值给count。这几个操作无法构成原子操作的,在一个线程读取完count值时,另一个线程也读取他并给它赋值,根据缓存一致性协议通知其他线程把本次读取的值置为无效,所以本次循环操作是无效的,我们看到的值不一定等于10000,如何进行更正---->synchronized关键字

public class ThreadDemo3 {
    private volatile static int count = 0;
    private static Object object = new Object();
    public static void main(String[] args) {
        for (int i = 0; i < 10; ++i){
            Thread thread = new Thread(()->{
                for (int j = 0; j < 1000; ++j){
                    synchronized (object){
                        count++;
                    }
                }
            });
            thread.start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("count执行的结果为->" + count);
    }
}

执行结果

count执行的结果为->10000

加锁后,线程在争夺执行权就必须获取到锁,当前线程就不会被其他线程所干扰,保证了count++的原子性,至于synchronized为什么能保证原子性,篇幅有限,下一篇在介绍。

有序性

jmm内存模型允许编译器和CPU在单线程执行结果不变的情况下,会对代码进行指令重排(遵守规则的前提下)。但在多线程的情况下却会影响到并发执行的正确性。

public class ThreadDemo4 {
    private static int x = 0,y = 0;
    private static int a = 0,b = 0;
    private static int i = 0;
    public static void main(String[] args) throws InterruptedException {
        for (;;){
            i++;
            x = 0;y = 0;
            a = 0;b = 0;
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    waitTime(10000);
                    a = 1;
                    x = b;
                }
            });
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    b = 1;
                    y = a;
                }
            });
            thread1.start();
            thread2.start();
            thread1.join();
            thread2.join();
            System.out.println("第" + i + "次执行结果(" + x + "," + y + ")");
            if (x == 0 && y == 0){
                System.out.println("在第" + i + "次发生指令重排,(" + x + "," + y + ")");
                break;
            }
        }
    }
    public static void waitTime(int time){
        long start = System.nanoTime();
        long end;
        do {
            end = System.nanoTime();
        }while (start + time >= end);
    }

}

执行结果

第1次执行结果(0,1)
第2次执行结果(1,0)
....
第35012次执行结果(0,1)
第35013次执行结果(0,0)
在第35013次发生指令重排,(0,0)

如何解决上诉问题哪?volatile的另一个作用就是禁止指令重排优化,它的底层是内存屏障,其实就是一个CPU指令,一个标识,告诉CPU和编译器,禁止在这个标识前后的指令执行重排序优化。内存屏障的作用有两个,一个就是上文所讲的保证变量的内存可见性,第二个保证特定操作的执行顺序。

补充

 指令重排序:Java语言规范规定JVM线程内部维持顺序化语义,程序的最终结果与它顺序化情况的结果相等,那么指令的执行顺序可以和代码顺序不一致。JVM根据处理器特性,适当的堆机器指令进行重排序,使机器指令更符号CPU的执行特性,最大限度发挥机器性能。

as-if-serial语义:不管怎么重排序,单线程程序的执行结果不能被改变,编译器和处理器都必须遵守这个原则。

happens-before原则:辅助保证程序执行的原子性,可见性和有序性的问题,判断数据是否存在竞争,线程是否安全的依据(JDK5)

1. 程序顺序原则,即在一个线程内必须保证语义串行性,也就是说按照代码顺序执行。

2. 锁规则 解锁(unlock)操作必然发生在后续的同一个锁的加锁(lock)之前,也就是说, 如果对于一个锁解锁后,再加锁,那么加锁的动作必须在解锁动作之后(同一个锁)。

3. volatile规则 volatile变量的写,先发生于读,这保证了volatile变量的可见性,简单 的理解就是,volatile变量在每次被线程访问时,都强迫从主内存中读该变量的值,而当 该变量发生变化时,又会强迫将最新的值刷新到主内存,任何时刻,不同的线程总是能 够看到该变量的最新值。

4. 线程启动规则 线程的start()方法先于它的每一个动作,即如果线程A在执行线程B的 start方法之前修改了共享变量的值,那么当线程B执行start方法时,线程A对共享变量 的修改对线程B可见

5. 传递性 A先于B ,B先于C 那么A必然先于C

6. 线程终止规则 线程的所有操作先于线程的终结,Thread.join()方法的作用是等待当前 执行的线程终止。假设在线程B终止之前,修改了共享变量,线程A从线程B的join方法 成功返回后,线程B对共享变量的修改将对线程A可见。

7. 线程中断规则 对线程 interrupt()方法的调用先行发生于被中断线程的代码检测到中 断事件的发生,可以通过Thread.interrupted()方法检测线程是否中断。

 

加载全部内容

相关教程
猜你喜欢
用户评论