Synchronized/volatile/AtomicInteger/LongAdder总结

 

Synchronized是悲观锁、独占锁、非公平锁，可以重入，一个线程获得锁，其他线程都要阻塞等待其释放锁，并发性能差，可以保证原子性，线程安全的；

ReentrantLock也是悲观锁，支持公平锁，可重入，与Synchronized相似；

ReadWriteLock读写锁，读锁是共享锁，写锁是独占锁；读写互斥，只允许一个线程写入（其他线程既不能写入也不能读取），没有写入时，多个线程允许同时读（提高性能）；

Volatile保证共享变量在内存中的可见性，禁止指令重排序，不保证原子性，多线程下的写有线程安全问题；

AtomicX类使用硬件层面的CAS操作，多线程下，只有一个线程写成功，其他线程自旋尝试，直到成功，保证原子性，线程安全。

LongAdder类与AtomicLong类的区别在于高并发时前者将对单一变量的CAS操作分散为对数组cells中多个元素的CAS操作，取值时进行求和，减少了线程自旋次数；而在并发较低时仅对base变量进行CAS操作，与AtomicLong类原理相同；

 

Atomic操作使用demo:

package com.drz.proxy.internetProxy.util;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 使用两个线程，从给定值0开始一个线程加1循环给定次数，一个减1循环相同次数，如果线程安全，则最后给定值还是0
 *
 */
public class AtomicAndVolatile {

    public static volatile int count = 0; // 计数器

    public static AtomicInteger ai = new AtomicInteger();

    public static final int size = 100000; // 循环测试次数

    public static void main(String[] args) throws InterruptedException {
        // ++ 方式 10w 次
        Thread thread = new Thread(() -> {
            for (int i = 1; i <= size; i++) {
                //                count++;
                ai.incrementAndGet();
            }
        });
        // -- 10w 次

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= size; i++) {
                //                count--;
                ai.decrementAndGet();
            }
        });
        thread.start();
        thread2.start();

        thread.join();
        thread2.join();
        //        System.out.println(count); // 打印结果 ：count 不为0
        System.out.print(ai.get());//打印结果为0
    }

}

AtomicAndVolatile