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
    }

}

ReadAndWriteLock使用demo

package com.drz.proxy.internetProxy.util;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadAndWriteLockTest {

    public static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        //同时读、写
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(new Runnable() {
            @Override
            public void run() {
                writeFile(Thread.currentThread());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                readFile(Thread.currentThread());
            }
        });
        service.shutdown();
    }

    // 读操作
    public static void readFile(Thread thread) {
        lock.readLock().lock();
//        boolean readLock = lock.isWriteLocked();
//        if (!readLock) {
            System.out.println("当前为读锁！");
//        }
        try {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(thread.getName() + ":正在进行读操作……");
            }
            System.out.println(thread.getName() + ":读操作完毕！");
        } finally {
            System.out.println("释放读锁！");
            lock.readLock().unlock();
        }
    }

    // 写操作
    public static void writeFile(Thread thread) {
        lock.writeLock().lock();
//        boolean writeLock = lock.isWriteLocked();
//        if (writeLock) {
            System.out.println("当前为写锁！");
//        }
        try {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(thread.getName() + ":正在进行写操作……");
            }
            System.out.println(thread.getName() + ":写操作完毕！");
        } finally {
            System.out.println("释放写锁！");
            lock.writeLock().unlock();
        }
    }
    //    执行结果：
    //    当前为写锁！
    //    pool-1-thread-1:正在进行写操作……
    //    pool-1-thread-1:正在进行写操作……
    //    pool-1-thread-1:正在进行写操作……
    //    pool-1-thread-1:正在进行写操作……
    //    pool-1-thread-1:正在进行写操作……
    //    pool-1-thread-1:写操作完毕！
    //    释放写锁！
    //    当前为读锁！
    //    pool-1-thread-2:正在进行读操作……
    //    pool-1-thread-2:正在进行读操作……
    //    pool-1-thread-2:正在进行读操作……
    //    pool-1-thread-2:正在进行读操作……
    //    pool-1-thread-2:正在进行读操作……
    //    pool-1-thread-2:读操作完毕！
    //    释放读锁！

}