volatile

介绍

可见性问题

让一个线程对共享变量的修改，能够及时的被其他线程看到。
根据JMM中规定的happen before和同步原则:
- 对某个 volatile字段的写操作happens-before每个后续对该volatile字段的读操作。
- 对volatile变量v的写入，与所有其他线程后续对v的读同步

要避免可见性问题，volatile 需要具有哪些功能

禁止缓存;
volatile变量的访问控制符会加个ACC _VOLATILE
https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.htmltjvms-4.5
对volatile变量相关的指令不做重排序;

线程安全

临界区和竞态条件

竞态条件：临界区内，引发线程安全问题的代码。
临界区：多线程情况下，会发生线程安全问题的区域。

共享资源

如果一段代码是线程安全的，则它不包含竞态条件。只有当多个线程更新共享资源时，才会发生竞态条件。

栈封闭时，不会在线程之间共享的变量，都是线程安全的。

局部对象引用本身不共享，但是引用的对象存储在共享堆中。如果方法内创建的对象，只是在方法中传递，并且不对其他线程可用，那么也是线程安全的。

public void someMethod(){
    Localobject localobject = new Localobject();
    localobject.callMethod();
    method2(localobject);
}
public void method2(Localobject localobject{
	localobject.setValue("value");
}

不可变对象

创建不可变的共享对象来保证对象在线程间共享时不会被修改,从而实现线程安全。实例被创建，value变量就不能再被修改，这就是不可变性。

public class Demo{
    private int value = O;
    public Demo(int value){
    	this.value = value;
    }
    public int getValue(){
    	return this.value;
    }
}

原子操作

本质：数据的一致性

原子性的定义

原子操作影响到的变量，在一起原子操作中，保持一致性（不能发生变动或者说不能被修改）。

CAS机制

接近于直接性的内存操作

利用 Unsafe 实现原子性

取 unsafe.getIntVolatile

改

写

static{
    try{
        //反射技术拿到对象
        Field theUnsafe = Unsafe.class. getDeclaredField( name: "theUnsafe");
        theUnsafe.setAccessible(true);
        unsafe = (Unsafe)theUnsafe.get(null):
        //利用unsafe,通过属性的偏离量(定位到内存中对象内具体的属性的内存地址)
        iOffset = unsafe.objectFieldPffset(LockDemo1.class.getDeclaredField(name: "i")) :
    } catch (Exception ex) {
        ex.printStackTrace();
	}
}
//优化
public void add(){
    int current; 
    //i++;
    current = unsafe.getIntVolatile( o: this, iOffset);
    unsafe.compareAndSwapInt( o: this.iOffset, current, i1: current + 1):
    // CAS命令
}

getIntVolatile 注意这个 volatile，禁止了指令重排以及缓存
全都是 native 修饰的本地方法
- native 非java方法，使用 C 实现的。
unsafe 是根据变量相对于当前对象的偏移量，去获取到当前变量在内存中位置的
缺点：高并发的情况下，会不断重试，造成资源损耗。

使用 Atomic 实现原子性

原理：自旋锁

// volatile int i = 0;
AtomicInteger i = new AtomicInteger(initialValue: 0) ;
public void add() {
    i.incrementAndGet():// i++
}

使用 LongAdder 实现原子性

since：JDK 1.8+

大数据处理思路 >>> 分而治之
每一个线程都有一个独享的累加器，在需要求和的时候，再取出来相加。避免了重试（Atomic）或者竞争（sync）。
适合高写，低读的场景

CAS 存在的几个问题

ABA问题

What
- 本该失败的操作确成功了，导致没办法体现出数据的变化。
Why
- 线程1 和线程2 同时发起了对于变量 i 的 CAS请求。正确情况下，应该某一线程会失败（这里假设线程2 会失败）
- 但在线程1 成功执行后，线程3 先于线程2 执行了。将 i 改回了线程2
- 线程2 认为，i 的值还是为 1 ，是我要找到，所以又把 i 的值变成了 2
How
- 不要将数据定义为简单的基本数据类型

如何避免

使用带有版本号的 J.U.C 类
不在只是判断数值和结果
数据的变动会通过版本号被记录下来
compare 的时候会增加对于版本号的对比

J.U.C 包提供的原子操作类

思想

分而治之

统计一个图片的点击数

多台服务器去分别统计，别分别记录
汇总服务器汇总所有记录

版权声明

本文作者：** 留夕

本文链接： **https://www.yuque.com/diamond/ndvfcc/sncxbg/

版权声明： **本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 许可协议。转载请注明出处！

首发日期： **2019-6-26 22:09:01