Java并发编程之可见性,有序性,原子性

Java 专栏收录该内容
1 篇文章 0 订阅

1. 原子性

问题引入

public class T01_Volatile {
    private boolean running = true;
    private void m(){
        System.out.println("m start");
        while (running){

        }
        System.out.println("m end");
    }
    public static void main(String[] args) throws InterruptedException, IOException {
        T01_Volatile t = new T01_Volatile();
        new Thread(t::m,"T01").start();
        Thread.sleep(1000);
        t.running = false;
    }
}

上面是一段小程序,逻辑很简单,开启一个子线程运行m方法,方法开始打印m start,之后是个死循环,主线程沉睡一秒后将running设置为false,死循环结束,接着打印m end,运行程序:

m start

奇怪的现象发生了,主线程将running设置为了false,只打印了m start ,m end 并没有执行,说明子线程的循环并没有结束,这是因为主线程和子线程在不同的cpu内核上运行,程序运行的时候主线程和子线程会把runing拷贝一份放在自己的缓存区,程序运行后他们都各自操作的是自己缓存区的runing,主线程对running的修改对子线程来说是不可见的。

接下来我们对变量runing通过添加volatile关键字进行修饰,如下所示:

private volatile boolean runing = true;

再次运行,log打印:

m start
m end

程序结束了,m end被打印了,通过volatile修饰的变量能保证线程之间数据的同步,主线程将runing设置为false之后,子线程是及时可见的,这就是volatile的主要作用。

有的同学可能有过这样的测试,将runing的volatile关键字设置remove掉,在while循环中打印一句话,即:

    private boolean running = true;
    private void m(){
        System.out.println("m start");
        while (running){
            System.out.println("ok");
        }
        System.out.println("m end");
    }

此时运行程序发现m end也打印了,这是为什么呢?这是因为System.out.println方法是一个同步的方法,源码如下:

 public void println(String x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

在多线程编程模型中某些语句会触发数据同步机制,此时synchronized语法,synchronized关键字不但保证了原子性,还保证的数据的可见性。

什么是程序?什么是进程?什么是线程

wechat.exe点击运行发生了什么?

  • 1.分配内存空间,拷贝相关资源到内存中,进程被创建

  • 2.找到的主线程入口函数开始执行

  • 3.第一条指令被传递到cpu的pc区,由他来记录(程序计数器)

  • 4.第一条指令的数据传递到cpu的Registers(寄存器)

  • 5.cpu的ALU开始计算 (计算单元)

  • 6.cpu计算完毕将数据回传给内存

存指令,存数据,计算,cpu的速度比内存高的多,cup计算单元访问寄存器的速度是它访问内存速度的100倍


计算机缓存架构,在cpu和内存之前存在很多缓存区

running没有更新的本质

上面我们主要了解一个程序运行之后的工作流程,下面我们主要来看看多线程情况下她到底是怎么运行的,在cpu和主内存存在三个缓冲区,如下图所示的L1,L2,L3,还是以之前我们所讲的那个实例为例,当子线程启动的时候,会把running从内存依次读到L3,L2,L1,然后ALU计算的时候,先从L1查找running,如果L1有就直接用了,没有L1没有回继续往下的L2查找,如果在L2找到了就直接用了,否则继续往L3找,L3没有找到会在主内存找,至于主内存在什么时候进行数据同步,这个时间不确定,正是由于这个原因就导致了running的值一直是ture,而主线程设置的false,只是在主线程所在的缓存中更新了,主内存中的running并没有更新。

volatile bytecodeInterpreter.cpp,volatile的最终实现是一条汇编指令 lock addL lock锁住了cpu到内存的联通线,lock指令不能单独存在

一核一线程

volite本质是汇编指令lock和addl ,bytecode.cpp ,本质就是一把锁,锁缓存或锁总线,lock指令不能但是存在,她的本质意思是当我执行后面的这条指令的时候,锁缓存或者锁总线。

缓存行

MESI缓存一致性协议,时不时的会触发一下,来保持数据的一致性,把两个x拆开,他们位于不同的内存空间,一个缓存行,读的是一块数据

MESI协议,没有上锁是一种不及时的同步,不管加不加v,s底层永远存在,慢:同一个缓存行,数据同步有消耗,快:在不同的缓存行,不需要同步数据。

public class T02_CacheLinePadding {
    public static long COUNT = 10_0000_0000L;
    private static class T{
        private long p1,p2,p3,p4,p5,p6,p7;
        public long x = 0L;
        private long p11,p22,p33,p44,p55,p66,p77;
    }
    public static T[] arr = new  T[2];
    static {
        arr[0] = new T();
        arr[1] = new T();
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(2);
        Thread t1 = new Thread(()->{
            for(long i = 0; i <COUNT;i++){
                arr[0].x = i;
            }
            latch.countDown();
        });
        Thread t2 = new Thread(()->{
            for(long i = 0; i <COUNT;i++){
                arr[1].x = i;
            }
            latch.countDown();
        });
        final long start = System.nanoTime();
        t1.start();
        t2.start();
        latch.await();
        System.out.println((System.nanoTime() - start)/100_0000);
    }
}

2.有序性

public class T03_Disorder {
    private static int x = 0, y = 0;
    private static int a = 0, b = 0;

    public static void main(String[] args) throws InterruptedException {
        int i = 0;
        for (; ; ) {
            i++;
            x = 0;
            y = 0;
            a = 0;
            b = 0;
            Thread one = new Thread(new Runnable() {
                public void run() {
                    //由于线程one先启动,下面这句话让它等一等线程two. 读着可根据自己电脑的实际性能适当调整等待时间.
                    //shortWait(100000);
                    a = 1;
                    x = b;
                }
            });

            Thread other = new Thread(new Runnable() {
                public void run() {
                    b = 1;
                    y = a;
                }
            });
            one.start();
            other.start();
            one.join();
            other.join();
            String result = "第" + i + "次 (" + x + "," + y + ")";
            if (x == 0 && y == 0) {
                System.err.println(result);
                break;
            } else {
                System.out.println(result);
            }
        }
    }
}

乱序执行,不是两个线程之间的乱序执行,而是同一个线程中代码的乱序执行,乱序执行是为了提供程序的运行效率,烧水泡茶的例子,线程的执行结果能保证最终的一致性,此时就可能发生乱序来提升效率

不能重排:

x++
x = x + 1

可以重排:

 a = 1;
 x = b;
public class T04_NoVisbllity {
    private static boolean ready = false;
    private static int number;
    private static class ReaderThread extends Thread{
        @Override
        public void run() {
            while (!ready){
                Thread.yield();
            }
            System.out.println(number);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t = new ReaderThread();
        t.start();
        number = 42;
        ready = true;
        t.join();
    }
}

可能一直处于没有准备好,ready的是不可见的,虽然ready被主线程修改,另外可能打印的结果为0,因为:

number = 42;
ready = true;

可能会出现指令重排

public class T05_ThisEscape {
    private int num = 8;

    public T05_ThisEscape() {
        new Thread(()->{
            System.out.println(this.num);
        }).start();
    }

    public static void main(String[] args) throws IOException {
        new T05_ThisEscape();
        System.in.read();
    }
}

num的打印结果可能为0,this是一个半初始化状态

public class T06_SingleInstance {
    private static T06_SingleInstance instance;
    private T06_SingleInstance() {
    }
    public static T06_SingleInstance getInstance() {
        if(instance == null){
            synchronized (T06_SingleInstance.class){
                if(instance == null){
                    instance = new T06_SingleInstance();
                }
            }
        }
        return instance;
    }
}

instance 可能由于指令重排而导致的处于半初始化状态,加上volatile关键字即可,禁止指令重排。

3.原子性

synchronized的实现过程:

  • 1.Java代码:synchronized
  • 2.字节码:monitorenter moniterexit
  • 3.jvm:自动升级
  • 4.汇编:lock comxchg

工作原理

synchronized互斥锁的本质是原子性,把下面的整体操作当成一个原子,一个线程执行完毕,另外一个线程才能执行,把原来并发执行的程序,变成序列化执行。

在Java SE 1.5之前,多线程并发中,synchronized一直都是一个元老级关键字,而且给人的一贯印象就是一个比较重的锁。为此,在Java SE 1.6之后,这个关键字被做了很多的优化,从而让以往的“重量级锁”变得不再那么重。

synchronized主要有两种使用方法,一种是代码块,一种关键字写在方法上。这两种用法底层究竟是怎么实现的呢?在1.6之前是怎么实现的呢?

字节码实现原理 在java语言中存在两种内建的synchronized语法:1、synchronized语句;2、synchronized方法。对于synchronized语句当Java源代码被javac编译成bytecode的时候,会在同步块的入口位置和退出位置分别插入monitorenter和monitorexit字节码指令。而synchronized方法则会被翻译成普通的方法调用和返回指令如:invokevirtual、areturn指令,在VM字节码层面并没有任何特别的指令来实现被synchronized修饰的方法,而是在Class文件的方法表中将该方法的access_flags字段中的synchronized标志位置1,表示该方法是同步方法并使用调用该方法的对象或该方法所属的Class在JVM的内部对象表示Klass做为锁对象。

那么monitorenter和monitorexit以及access_flags底层又是通过什么底层技术来实现的原子操作呢?

Mutex Lock

简单来说在JVM中monitorenter和monitorexit字节码依赖于底层的操作系统的Mutex Lock来实现的,但是由于使用Mutex Lock需要将当前线程挂起并从用户态切换到内核态来执行,这种切换的代价是非常昂贵的。

那么我们来看看mutex lock又是一个什么鬼?

我们来看看常见的linux的内核互斥锁长什么样:

/linux/include/linux/mutex.h

struct mutex {
         /* 1: unlocked, 0: locked, negative: locked, possible waiters */
         atomic_t                count;
         spinlock_t              wait_lock;
         struct list_head        wait_list;
  #ifdef CONFIG_DEBUG_MUTEXES
          struct thread_info      *owner;
          const char              *name;
         void                    *magic;
  #endif
  #ifdef CONFIG_DEBUG_LOCK_ALLOC
          struct lockdep_map      dep_map;
 #endif
 };

mutex lock的作用及访问规则:

mutex lock互斥锁主要用于实现内核中的互斥访问功能。mutex lock内核互斥锁是在原子 API 之上实现的,但这对于内核用户是不可见的。对它的访问必须遵循一些规则:同一时间只能有一个任务持有互斥锁,而且只有这个任务可以对互斥锁进行解锁。互斥锁不能进行递归锁定或解锁。一个互斥锁对象必须通过其API初始化,而不能使用memset或复制初始化。一个任务在持有互斥锁的时候是不能结束的。互斥锁所使用的内存区域是不能被释放的。使用中的互斥锁是不能被重新初始化的。并且互斥锁不能用于中断上下文。但是互斥锁比当前的内核信号量选项更快,并且更加紧凑,因此如果它们满足您的需求,那么它们将是您明智的选择。

对象在内存中的布局

Java Object Layout

Object obj = new Object(); 16个字节

makword 8个字节
classpointer 8个字节
成员变量:0个字节

User :int id String main
makword 8个字节
classpointer 4个字节 (压缩)
int 4
String 4
共20个字节 24

锁升级

CAS工作原理


CAS底层:lock cmpxchg 本质是锁定北桥芯片的一个电信号

总结

在java6之前,synchronized关键字就是那个很重的互斥锁。我们之所以说它重,是因为底层需要进行用户态到内核态的切换。于是在java6中对synchronized进行了优化。减少底层的切换,于是有了轻量级锁,只是进行基本的CAS原子操作;然而CAS还是会涉及的底层,于是又有了偏向锁,通过mark word对象头中的thread ID进行置换,如果下次还是同样的线程,那么就直接进入,而不再需要进行CAS底层原子操作。另外我们也介绍了锁消除这种机制,从而减少了一些根本不必要的同步。我们还简单的讨论了锁粗化,这是一种减少我们频繁的获取和释放锁的不错的做法

学习交流

欢迎入群交流学习,Android、Java开发技术交流群

  • QQ群:810970432
  • email:geduo_83@163.com
  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

<p> <span style="color:#E53333;">课程介绍:</span> </p> <p> <br /> </p> <p style="color:#353535;"> 对于一个Java程序员而言<strong>能否熟练掌握并发编程是判断他优秀与否的重要标准一</strong>。因为并发编程Java语言中最为晦涩的知识点它涉及操作系统、内存、CPU、编程语言等多方面的基础能力更为考验一个程序员的内功。 </p> <p style="color:#353535;"> 那到底应该怎么学习并发编程呢?Java SDK的并发工具包有很多是要死记硬背每一个工具的优缺点和使用场景吗?当然不是想要学好并发编程你需要从一个个单一的知识和技术中“跳出来”高屋建瓴地看问题并逐步建立自己的知识体系。 </p> <p style="color:#353535;"> 本课程希望能够帮助你建立起一张处理并发问题的全景图让你能够彻底理解并发问题的本质所在。同时课程还会深入介绍Java并发编程技术背后的逻辑关系以及应用场景助你能够游刃有余地游走在这些技术中。 </p> <p style="color:#353535;"> <br /> </p> <p> <span style="color:#E53333;">课程核心知识点:</span> </p> <p> <span>1. 线程安全分析主要内容包括原子性可见有序性等分析。以及Atomic包; CAS算法、Synchronized、Lock、Happens-before等。</span> </p> <span>2. 线程的安全手段ThreadLocal、同步容器、并发容器、J.U.C包等</span><br /> <span>3. AQS以及其他J.U.C组件如CountDownLatch、Semaphore、CycliBarrier、ReentrantLock</span><br /> <span>4. 线程池的原理</span><br /> <p> <span>5. ConcurrentHashMap等</span> </p> <p> <span><br /> </span> </p> <p> <span style="color:#E53333;">课程大纲:</span> </p> <p> <span><img src="https://img-bss.csdnimg.cn/202006050424053986.png" alt="" /><br /> </span> </p>
相关推荐
©️2020 CSDN 皮肤主题: 撸撸猫 设计师:马嘣嘣 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值