Java并发机制底层实现原理-原子操作的实现原理

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

Java并发机制底层实现原理-原子操作的实现原理

markfork 2018-04-29 19:45:00 浏览323
展开阅读全文

章节目录

  • 原子操作含义
  • 相关术语
  • 保证多处理器操作原子性的两种方式
  • Java语言层面上实现原子操作

原子操作的含义:

原子本意是"不能被进一步分割的最小粒子",而原子操作意为,不可中断的一个或一系列操作。

相关术语

术语名称 英文 解释
缓存行 Cache line 缓存的最小操作单位
比较并交换 Compare and Swap CAS操作需要输入两个数值,一个旧值(期望操作前的值)和一个新值,在操作期间先比较旧值有没有发生变化,如果没有发生变化,才交换成新值,发生变化,表示有多线程竞争,则不交换

保证多处理器操作原子性的两种方式

  • 通过总线锁保证操作共享变量是原子性的
如果多个处理器同事对共享变量进行读改写操作(i++是经典的读改写操作),那
么共享变量就会被多个处理器同时进行操作,这样读改写操作就不是原子性的,操作完之后,共享变量的值会和期望的不一致。
如:
public class IncreaceThread implements Runnable {
    public int i = 1;

    public void run() {
        this.i = ++i;
    }

    public int getI(){
        return this.i;
    }

    public static void main(String[] args) {
        IncreaceThread increaseThread = new IncreaceThread();
        Thread thread1 = new Thread(increaseThread);
        Thread thread2 = new Thread(increaseThread);
        thread1.start();
        thread2.start();
        System.out.println(increaseThread.getI());
    }
}
计算出最终i的值有可能是2,而不是3。
原因可能是多个处理器同时从各自的缓存中读取变量i,分别进行+1操作,然后分别写入到系统内从中。
想要保证改写共享变量的操作是原子的,那就必须保证CPU1读改写共享变量的
时候,CPU2不能操作缓存了该共享变量内存地址的缓存。
处理器使用总线锁来解决这个问题,所谓总线锁,就是处理器提供一个LOCK#信号,当一个处理器在总线上输出此信号时,
其他处理器的请求将被阻塞住,那么该处理器可以独占共享内存。
  • 使用缓存锁保证原子性
第二个机制是通过缓存锁定来保证原子性。
同一时刻,我们只需保证对某个内存地址的操作是原子性即可,但总线锁定把CPU 和内存之间的通信锁住,这使得锁定期间,其他处理器不能操作其他内存地址的数据,所以总线锁的开销比较大。
使用缓存锁定开销会变小,缓存锁定,是指内存区域如果被缓存在处理器缓存行中,并且在Lock操作期间被锁定,那么当它执行锁操作回写到内存时,处理器不在总线上声言LOCK#信号,而是修改内部的内存地址,并允许它的缓存一致性来保证操作的原子性。

Java语言层面上实现原子操作

在Java中通过锁和循环CAS的方式实现原子操作

使用循环CAS实现原子操作

JVM中的CAS操作正式利用了处理器提供的cmpxchg指令实现的,自旋基本思路就是循环进行CAS操作知道成功为止,以下代码实现可一个基于CAS线程安全的计数器方法safeCount 和一个非线程安全的计数器count。

package com.imooc.item;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger atomicInteger = new AtomicInteger(0);
    private int i = 0;

    public void safeCount() {
        for (; ; ) {
            int i = atomicInteger.get();
            boolean suc = atomicInteger.compareAndSet(i, ++i);
            if (suc) {
                break;
            }
        }
    }

    //线程计数器
    public void count() {
        i++;
    }

    public static void main(String[] args) {
        final Counter cas = new Counter();
        List<Thread> ts = new ArrayList<Thread>(600);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100; i++) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        cas.count();
                        cas.safeCount();
                    }
                }
            });
            ts.add(t);
        }

        //开始运行线程
        for (Thread t : ts) {
            t.start();
        }

        //等待所有线程执行完毕
        for (Thread t : ts) {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(cas.i);
        System.out.println(cas.atomicInteger.get());
        System.out.println(System.currentTimeMillis() - start);
    }
}

运行结果如下所示:

996309
1000000
61

CAS实现原子操作的三大问题

  • ABA 问题
因为CAS需要在操作值的时候,检查值有没有发生变化,如果没有发生变化则
更新,但如果一个值原来是A,变成了B,又变成了A,那么使用CAS进行检查时会
发现它的值没有发生变化,但实际上却变了,ABA问题的解决思路就是使用版
本号,在变量前面加上版本号,每次变量更新的时候把版本号加1。
那么A->B->A问题就会变成1A-2B-3A.
  • 循环时间开销大
自旋CAS如果长时间不成功,会给CPU带来非常大的执行开销。常用做法是控制自旋的次数。
  • 只能保证一个共享变量的原子操作
当对一个共享变量执行操作时,我们可以使用循环CAS的方式保证原子操作,
但是对多个共享变量操作时,循环CAS就无法保证操作的原子性,这个时候可
以用锁。

使用锁机制实现原子操作

  • 锁机制保证了只有获得锁的线程才能够 操作锁定的线程共享区域(临界区),
JVM内部实现了很多的锁机制:偏向锁、轻量级锁和互斥锁。其中,除了偏向
锁,JVM实现锁的方式都使用了循环CAS,即当一个线程想进入同步块的时候使
用循环CAS的方式获取锁,当它退出同步块的时候使用循环CAS释放锁。

网友评论

登录后评论
0/500
评论
markfork
+ 关注