Java Atomic Synchronsized Volatile

Java Atomic Synchronsized Volatile

##Atomic 原子

    private static AtomicInteger count = new AtomicInteger(0);count.addAndGet(1);

我们看一下count.addAndGet(1)的实现就明白了

public final int addAndGet(int delta) {
    return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}

//var1,是count对象，var2是count的值，var4是 addAndGet(1)的参数1
public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;do {
    var5 = this.getIntVolatile(var1, var2);
//使用while循环从主内存中得到当前的count值var5去和当前的var2比较看有没有其他线程在当前线程运行过程中改变了count的值} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));return var5;}

####LongAdder和DoubleAdder

这两个是Java8的新增的原子操作类，为了解决cas中并发写入时多次循环读取的问题

单线程下AtomicLong快点，多线程下LongAdder快，但是在多线程下LongAdder不保证严格的一致性

具体分析：https://blog.csdn.net/yao123long/article/details/63683991

AtomicStampedReference

为了解决ABA的问题可以使用

##Synchronsized 原子 有序 可见

Synchronsized最需要注意的是他不是方法声明的一部分，所以他不可以被子类继承这句话不太对的

@Slf4j
public class SynchronsizedDemo1 {
    public synchronized void testSynchronsizesd1(int j) {
    for (int i = 0; i < 100; i++) {
    log.info("thread:{}-->{}", j, i);}}
}//1.如果子类没有显示的重写testSynchronsizesd1方法，调用的就是父类的方法，显然是对的
@Slf4j
public class SynchronsizedDemo2 extends SynchronsizedDemo1{
    public static void main(String[] args) {
    SynchronsizedDemo2 synchronsizedDemo1 = new SynchronsizedDemo2();SynchronsizedDemo2 synchronsizedDemo2 = new SynchronsizedDemo2();ExecutorService executorService = Executors.newCachedThreadPool();executorService.execute(() -> {
    synchronsizedDemo1.testSynchronsizesd1(1);});executorService.execute(() -> {
    synchronsizedDemo2.testSynchronsizesd1(2);});executorService.shutdown();}
}//2.这样继承重写方法不加synchronsized关键字掉用的就是子类的方法，自然不是原子性的有线程安全问题
@Slf4j
public class SynchronsizedDemo2 extends SynchronsizedDemo1{
    @Overridepublic void testSynchronsizesd1(int j) {
    for (int i = 0; i < 100; i++) {
    log.info("thread:{}-->{}", j, i);try {
    Thread.sleep(20);} catch (InterruptedException e) {
    e.printStackTrace();}}}public static void main(String[] args) {
    SynchronsizedDemo2 synchronsizedDemo1 = new SynchronsizedDemo2();SynchronsizedDemo2 synchronsizedDemo2 = new SynchronsizedDemo2();ExecutorService executorService = Executors.newCachedThreadPool();executorService.execute(() -> {
    synchronsizedDemo1.testSynchronsizesd1(1);});executorService.execute(() -> {
    synchronsizedDemo2.testSynchronsizesd1(2);});executorService.shutdown();}
}

Volatile 可见 有序

注意用法只是保证了内存的可见性，一般用在判断多线程情况下某个变量的变化，如双检锁的单例模式

/*** @Author: wei1* @Date: Create in 2018/12/13 16:45* @Description: 使用volatile来实现单例，这样的单例是线程安全的懒汉式*/
public class SingletonDemo2 {
    // 1、memory = allocate() 分配对象的内存空间// 2、ctorInstance() 初始化对象// 3、instance = memory 设置instance指向刚分配的内存// JVM和cpu优化，发生了指令重排//2.3两步没有必然的联系，如果3在2之前发生的化，其他线程就会拿到还未初始化的对象// 1、memory = allocate() 分配对象的内存空间// 3、instance = memory 设置instance指向刚分配的内存// 2、ctorInstance() 初始化对象//使用volatile关键字来禁止上述的指令重排private volatile SingletonDemo2 singleTon;//构造方法私有private SingletonDemo2() {
    }public SingletonDemo2 getInstance() {
    if (singleTon == null) {
    synchronized (this) {
    if (singleTon == null) {
    return new SingletonDemo2();}}}return singleTon;}
}