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{
    
    @Override
    public 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;
    }
}