JAVA常用的锁机制

刺骨的言语ヽ痛彻心扉 2021-11-14 12:50 313阅读 0赞

在开发多线程应用的时候(并发编程)，为了防止多个线程同时去修改一个变量的时候产生数据不一致性。这个时候就必须要用到锁机制。有一个线程在修改的时候我先加锁，等修改完了在释放锁。资源被锁住的时候不允许其他线程修改。这也是我们JAVA里面锁的初衷。咱们JAVA里面的锁有：synchronized、ReentrantLock、ReadWriteLock、Semaphore、CountDownLatch。

这样我们先讲怎么来使用这些锁，然后我们在讲锁的分类。

# 一 锁的使用 #

## 1.1 synchronized ##

synchronized关键字可以用来给方法或者代码块加锁。synchronized是独享锁，互斥锁，可重入锁，非公平锁。

/**
         * 相对于Object lockObject = new Object();而言
         * 推荐用byte[] lockObject = new byte[0]
         * 后者汇编语句少。执行快
         */
        private final byte[] lockObject = new byte[0];
    
        /**
         * synchronized用来给方法加锁
         */
        public synchronized void lockFunction() {
            //TODO:
        }
    
        public void lockBlok() {
            //TODO
            // synchronized给代码块加锁
            synchronized(lockObject) {
                //TODO
            }
            //TODO
        }

## 1.2 ReentrantLock ##

ReentrantLock重入锁。实现Lock接口的一个类，也是在实际编程中使用频率很高的一个锁。ReentrantLock是重入锁，互斥锁，既可以设置成公平锁也可以设置成非公平锁。

> 稍微看下ReentrantLock的源码，AbstractQueuedSynchronizer这个类的代码我们没有分析。

public class ReentrantLock implements Lock, java.io.Serializable {
        private static final long serialVersionUID = 7373984872572414699L;
    
        private final Sync sync;
    
        /**
         * lock锁的同步控制，子类有公平和非公平两个版本。
         * 该抽象锁同步器主要提供了尝试获取（非公平实现）和尝试释放锁等功能
         */
        abstract static class Sync extends AbstractQueuedSynchronizer {
            private static final long serialVersionUID = -5179523762034025860L;
    
            // 获取锁，由子类实现
            abstract void lock();
    
            // 执行非公平的尝试获取锁操作
            final boolean nonfairTryAcquire(int acquires) {
                final Thread current = Thread.currentThread();
                int c = getState();
                // 如果锁没有被占用，则尝试获取锁
                if (c == 0) {
                    // 新的线程可能抢占已经排队的线程的锁的使用权 -- 非公平
                    if (compareAndSetState(0, acquires)) {
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                // 通过判断当前线程是否为获取锁的线程来决定获取操作是否成功，如果是获取锁的线程
                // 再次请求，则将同步状态值进行增加并返回true，表示获取同步状态成功。
                // 成功的获取锁的线程再次获取锁，只是增加了同步状态值
                else if (current == getExclusiveOwnerThread()) {
                    int nextc = c + acquires;
                    if (nextc < 0) // overflow
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }
    
            // 如果该锁被获取了n次，那么前(n-1)次tryRelease(int releases)方法必须返回false，而只有
            // 同步状态完全释放了，才能返回true。可以看到，该方法将同步状态是否为0作为最终释放
            // 的条件，当同步状态为0时，将占有线程设置为null，并返回true，表示释放成功。
            protected final boolean tryRelease(int releases) {
                int c = getState() - releases;
                if (Thread.currentThread() != getExclusiveOwnerThread())
                    throw new IllegalMonitorStateException();
                boolean free = false;
                if (c == 0) {
                    free = true;
                    setExclusiveOwnerThread(null);
                }
                setState(c);
                return free;
            }
    
            // 判断是否当前线程独占锁
            protected final boolean isHeldExclusively() {
                // While we must in general read state before owner,
                // we don't need to do so to check if current thread is owner
                return getExclusiveOwnerThread() == Thread.currentThread();
            }
    
            final ConditionObject newCondition() {
                return new ConditionObject();
            }
    
            // Methods relayed from outer class
    
            final Thread getOwner() {
                return getState() == 0 ? null : getExclusiveOwnerThread();
            }
    
            final int getHoldCount() {
                return isHeldExclusively() ? getState() : 0;
            }
    
            final boolean isLocked() {
                return getState() != 0;
            }
    
            /**
             * Reconstitutes the instance from a stream (that is, deserializes it).
             */
            private void readObject(java.io.ObjectInputStream s)
                    throws java.io.IOException, ClassNotFoundException {
                s.defaultReadObject();
                setState(0); // reset to unlocked state
            }
        }
    
        /**
         * 继承Sync， 并实现非公平锁
         */
        static final class NonfairSync extends Sync {
            private static final long serialVersionUID = 7316153563782823691L;
    
            // 阻塞获取锁， 当前线程优先去获取锁，获取失败在通过队列的方式获取
            final void lock() {
                if (compareAndSetState(0, 1))
                    setExclusiveOwnerThread(Thread.currentThread());
                else
                    acquire(1);
            }
    
            protected final boolean tryAcquire(int acquires) {
                return nonfairTryAcquire(acquires);
            }
        }
    
        /**
         * 继承Sync， 并实现公平锁
         */
        static final class FairSync extends Sync {
            private static final long serialVersionUID = -3000897897090466540L;
    
            // 阻塞获取锁
            final void lock() {
                acquire(1);
            }
    
            // 尝试获取锁（公平策略），不能保证获取，除非递归调用或没有其他的线程等待获取锁
            protected final boolean tryAcquire(int acquires) {
                final Thread current = Thread.currentThread();
                int c = getState();
                // 没有前驱，且设置锁标志位成功，获取锁成功, hasQueuedPredecessors()证了不论是新的线程还是已经排队的线程都顺序使用锁
                if (c == 0) {
                    if (!hasQueuedPredecessors() &&
                            compareAndSetState(0, acquires)) {
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                // 当前线程已经持有锁，重入
                else if (current == getExclusiveOwnerThread()) {
                    int nextc = c + acquires;
                    if (nextc < 0)
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }
        }
    
        /**
         * 创建ReentrantLock，默认是非公平锁
         */
        public ReentrantLock();
        public ReentrantLock(boolean fair);
    
        /**
         * 获取锁 拿不到lock就不罢休，不然线程就一直block
         * 1. 如果该锁没有被其他线程占用，则获取该锁并立即返回，将锁的保持计数设置为 1。
         * 2. 如果当前线程已经占用该锁，则将保持计数加 1，并且该方法立即返回。(可重入)。
         * 3. 如果该锁被另一个线程占用，该线程将一直block。直到其他线程释放该锁。在执行1操作。
         */
        public void lock();
    
        /**
         * lockInterruptibly方法和lock方法的区别在于，在阻塞等待获取锁的过程中是可以被其他线程
         * 打断的（比如在其他线程调用了获取锁线程的interrupt方法），而且这个时候会抛出InterruptedException
         */
        public void lockInterruptibly() throws InterruptedException;
    
        /**
         * 获取锁，马上返回，拿到lock就返回true，不然返回false。可以配置等待时间
         * 1. 如果该锁没有被其他线程占用，立即返回true值，则将锁的保持计数设置为1。
         * 即使已将此锁设置为使用公平排序策略，但是调用 tryLock() 仍将 立即获取锁（如果有可用的），
         * 而不管其他线程当前是否正在等待该锁。在某些情况下，此“闯入”行为可能很有用，即使它会打破公
         * 平性也如此。如果希望遵守此锁的公平设置，则使用 tryLock(0, TimeUnit.SECONDS)
         * ，它几乎是等效的（也检测中断）
         * 2. 如果当前线程已经占有此锁，则将保持计+1，该方法将返回 true。
         * 3. 如果锁被另一个线程占用，则此方法将立即返回false值。
         */
        public boolean tryLock();
        public boolean tryLock(long timeout, TimeUnit unit);
    
        /**
         * 释放锁
         */
        public void unlock();
    
        /**
         * 创建Condition，特定的condition能唤醒特定的线程
         */
        public Condition newCondition();
    
        /**
         * 返回的是查询当前线程保存此lock的个数
         */
        public int getHoldCount();
    
        /**
         * 查询当前线程是否保持此锁定
         */
        public boolean isHeldByCurrentThread();
    
        /**
         * 查询此锁定是否由任意线程保持
         */
        public boolean isLocked();
    
        /**
         * 判断lock锁是公平锁还是非公平锁
         */
        public final boolean isFair();
    
        /**
         * 是否有线程在等待获取锁
         */
        public final boolean hasQueuedThreads();
    
        /**
         * 查询参数线程是否在等待获取此锁
         */
        public final boolean hasQueuedThread(Thread thread);
    
        /**
         * 查询等待获取此锁线程的数量
         */
        public final int getQueueLength();
    
        /**
         * 作用是检测当前是否有线程已调用condition.await()并且处于await状态
         */
        public boolean hasWaiters(Condition condition);
    
        /**
         * 作用是检测当前是否有线程已调用condition.await()并且处于await状态的个数有多少个
         */
        public int getWaitQueueLength(Condition condition);
    
    }

public interface Condition {
    	/**
    	*Condition线程进入阻塞状态,调用signal()或者signalAll()再次唤醒，
    	*允许中断如果在阻塞时锁持有线程中断，会抛出异常；
    	*重要一点是：在当前持有Lock的线程中，当外部调用会await()后，ReentrantLock就允许其他线程来抢夺锁当前锁，
    	*注意：通过创建Condition对象来使线程wait，必须先执行lock.lock方法获得锁
    	*/
        void await() throws InterruptedException;
    
        //Condition线程进入阻塞状态,调用signal()或者signalAll()再次唤醒，不允许中断，如果在阻塞时锁持有线程中断，继续等待唤醒
        void awaitUninterruptibly();
    
        //设置阻塞时间，超时继续，超时时间单位为纳秒，其他同await()；返回时间大于零，表示是被唤醒，等待时间并且可以作为等待时间期望值，小于零表示超时
        long awaitNanos(long nanosTimeout) throws InterruptedException;
    
    	//类似awaitNanos(long nanosTimeout);返回值：被唤醒true，超时false
        boolean await(long time, TimeUnit unit) throws InterruptedException;
    
       //类似await(long time, TimeUnit unit) 
        boolean awaitUntil(Date deadline) throws InterruptedException;
    
       //唤醒指定线程
        void signal();
    	
        //唤醒全部线程
        void signalAll();
    }

ReentrantLock实现简单的加锁。lock()、unlock()的使用。

private final ReentrantLock reentrantLock = new ReentrantLock();
        private int value = 0;
    
        //----------------------------ReentrantLock lock 的使用
        @Test
        public void lock() {
            CountDownLatch latch = new CountDownLatch(20);
            for (int index = 0; index < 20; index++) {
                new Thread(() -> {
                    // 使用之前先获取锁
                    reentrantLock.lock();
                    try {
                        Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS);
                        value = value + 1;
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        // 使用完之后释放锁
                        reentrantLock.unlock();
                        latch.countDown();
                    }
                }).start();
            }
    
            try {
                // 等待所有的线程执行完
                latch.await();
                System.out.println("value = " + value);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }

ReentrantLock Condition的使用，Condition的强大之处在于它可以为多个线程间建立不同的Condition。下面我们用Codition实现一个简单的生产消费者。(代码是直接网上找的)

//-------------------------ReentrantLock condition 的使用
    
        class Buffer {
            private final ReentrantLock reentrantLock;
            private final Condition fullCondition;
            private final Condition emptyCondition;
            private final int maxSize;
            private final List<Date> storage;
    
            Buffer(int size) {
                // 使用锁lock，并且创建两个condition，相当于两个阻塞队列
                reentrantLock = new ReentrantLock();
                fullCondition = reentrantLock.newCondition();
                emptyCondition = reentrantLock.newCondition();
                maxSize = size;
                storage = new LinkedList<>();
            }
    
            // 往队列里面放数据
            public void put() {
                reentrantLock.lock();
                try {
                    while (storage.size() == maxSize) {
                        // 如果队列满了
                        System.out.print(Thread.currentThread().getName() + ": wait \n");
                        // 阻塞生产线程
                        fullCondition.await();
                    }
                    storage.add(new Date());
                    System.out.print(Thread.currentThread().getName() + ": put:" + storage.size() + "\n");
                    Thread.sleep(1000);
                    emptyCondition.signalAll();//唤醒消费线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    reentrantLock.unlock();
                }
            }
    
            // 从队列里面取出数据
            public void take() {
                reentrantLock.lock();
                try {
                    while (storage.size() == 0) {
                        // 如果队列满了
                        System.out.print(Thread.currentThread().getName() + ": wait \n");
                        // 阻塞消费线程
                        emptyCondition.await();
                    }
                    Date d = ((LinkedList<Date>) storage).poll();
                    System.out.print(Thread.currentThread().getName() + ": take:" + storage.size() + "\n");
                    Thread.sleep(1000);
                    // 唤醒生产线程
                    fullCondition.signalAll();
    
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    reentrantLock.unlock();
                }
            }
        }
    
        // 生产者
        class Producer implements Runnable {
            private Buffer buffer;
    
            Producer(Buffer b) {
                buffer = b;
            }
    
            @Override
            public void run() {
                while (true) {
                    buffer.put();
                }
            }
        }
    
        // 消费者
        class Consumer implements Runnable {
            private Buffer buffer;
    
            Consumer(Buffer b) {
                buffer = b;
            }
    
            @Override
            public void run() {
                while (true) {
                    buffer.take();
                }
            }
        }
    
        @Test
        public void condition() {
            Buffer buffer = new Buffer(10);
            Producer producer = new Producer(buffer);
            Consumer consumer = new Consumer(buffer);
            for (int i = 0; i < 3; i++) {
                new Thread(producer, "producer-" + i).start();
            }
            for (int i = 0; i < 3; i++) {
                new Thread(consumer, "consumer-" + i).start();
            }
    
            try {
                Thread.currentThread().join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

## 1.3 ReadWriteLock ##

ReadWriteLock读写锁，里面包含两个锁：读锁、写锁。

public interface ReadWriteLock {
        /**
         * 读锁
         */
        Lock readLock();
    
        /**
         * 写锁
         */
        Lock writeLock();
    }

ReadWriteLock让我们可以读写分离，分别对读和写上不同的锁。从而可以做到读和读互不影响，读和写互斥，写和写互斥，提高读的效率。ReadWriteLock接口也有一个实现类ReentrantReadWriteLock。有兴趣的可以去分析下ReentrantReadWriteLock具体的实现逻辑。

ReadWriteLock锁的特点：

*  如果其他线程占领了读锁，其他线程想要获取读锁。不需要等到，直接可以获取到。(读和读互不影响)
 *  如果其他线程占领了读锁，其他线程想要获取写锁。要等待读锁完成。(读和写互斥)
 *  如果其他线程占领了写锁，其他线程想要获取读锁或者写锁。要等到写锁的完成。(写和写互斥，写和读互斥)

private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    
        // 读操作
        private void readFile(Thread thread) {
            readWriteLock.readLock().lock();
            boolean readLock = readWriteLock.isWriteLocked();
            if (!readLock) {
                System.out.println("当前为读锁！");
            }
            try {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(thread.getName() + ":正在进行读操作……");
                }
                System.out.println(thread.getName() + ":读操作完毕！");
            } finally {
                System.out.println("释放读锁！");
                readWriteLock.readLock().unlock();
            }
        }
    
        // 写操作
        private void writeFile(Thread thread) {
            readWriteLock.writeLock().lock();
            boolean writeLock = readWriteLock.isWriteLocked();
            if (writeLock) {
                System.out.println("当前为写锁！");
            }
            try {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(thread.getName() + ":正在进行写操作……");
                }
                System.out.println(thread.getName() + ":写操作完毕！");
            } finally {
                System.out.println("释放写锁！");
                readWriteLock.writeLock().unlock();
            }
        }
    
    
        @Test
        public void readWriteLock() {
    
            ExecutorService readService = Executors.newCachedThreadPool();
            readService.execute(new Runnable() {
                @Override
                public void run() {
                    readFile(Thread.currentThread());
                }
            });
            ExecutorService writeService = Executors.newCachedThreadPool();
            writeService.execute(new Runnable() {
                @Override
                public void run() {
                    writeFile(Thread.currentThread());
                }
            });
    
            try {
                Thread.currentThread().join();
            } catch (InterruptedException e) {
                // ignore
            }
        }

## 1.4 Semaphore ##

Semaphore作用是控制线程的并发数量。就这一点而言，单纯的synchronized关键字是实现不了的。Semaphore类是一个计数信号量，必须由获取它的线程释放，通常用于限制可以访问某些资源（物理或逻辑的）线程数目。一个信号量有且仅有3种操作，且它们全部是原子的：初始化、增加和减少：增加可以为一个进程解除阻塞、减少可以让一个进程进入阻塞。

针对Semaphore，网上有一个很形象的比喻，Semaphore主要用于控制当前活动线程数目，就如同停车场系统一般，而Semaphore则相当于看守的人，用于控制总共允许停车的停车位的个数，而对于每辆车来说就如同一个线程，线程需要通过acquire()方法获取许可，而release()释放许可。如果许可数达到最大活动数，那么调用acquire()之后，便进入等待队列，等待已获得许可的线程释放许可，从而使得多线程能够合理的运行。

> 例子比较简单，我就直接从网上copy了一份过来了，

// 同步关键类，构造方法传入的数字是多少，则同一个时刻，只运行多少个线程同时运行制定代码
        private static final Semaphore semaphore = new Semaphore(3);
    
        private static class InformationThread extends Thread {
            private final String name;
            private final int age;
    
            InformationThread(String name, int age) {
                this.name = name;
                this.age = age;
            }
    
            @Override
            public void run() {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + ":大家好，我是:" + name + ",我今年:" + age + "岁。当前时间为：" + System.currentTimeMillis());
                    Thread.sleep(1000);
                    System.out.println(name + "要准备释放许可证了，当前时间为：" + System.currentTimeMillis());
                    System.out.println("当前可使用的许可数为：" + semaphore.availablePermits());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }
        }
    
        @Test
        public void semaphore() {
            String[] name = {"李明", "王五", "张杰", "王强", "赵二", "李四", "张三"};
            int[] age = {26, 27, 33, 45, 19, 23, 41};
            for (int i = 0; i < name.length; i++) {
                Thread t1 = new InformationThread(name[i], age[i]);
                t1.start();
            }
    
            try {
                Thread.currentThread().join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

## 1.5 CountDownLatch ##

CountDownLatch也是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。用给定的计数初始化CountDownLatch，由于调用了countDown()方法，所以在当前计数到达零之前，await方法会一直受阻塞。只有到零的之后，会释放所有等待的线程，await的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用CyclicBarrier。

@Test
        public void countDownLatch() {
            // CountDownLatch 初始值给10
            CountDownLatch countDownLatch = new CountDownLatch(10);
            // 启动10个线程，每个线程countDown
            for(int index = 0; index < 10; index++) {
                new Thread(() -> {
                    try {
                        Uninterruptibles.sleepUninterruptibly(10, TimeUnit.SECONDS);
                    } finally {
                        // countDownLatch减1
                        countDownLatch.countDown();
                    }
                }).start();
            }
            try {
                // 等待countDownLatch减为0
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

# 二 锁的分类 #

## 2.1 乐观锁/悲观锁 ##

乐观锁/悲观锁不是指具体类型的锁，是人们定义出来的概念或思想。主要是指看待并发同步的角度。

### 2.1.1 乐观锁 ###

乐观锁喜欢把所有的事情都往好的方面去想，认为不存在很多并发更新操作，每次去读取数据的时候，不会同时有其他线程去修改数据，不需要加锁操作。但是在更新时会判断其他线程在这之前有没有对数据进行修改。一般会使用“数据版本机制”或“CAS操作”来实现

数据库版本机制乐观锁的实现一般采用版本号实现乐观锁，而Java中可使用CAS实现乐观锁。

#### 2.1.1.1 数据库版本机制实现乐观锁 ####

数据库版本机制实现乐观锁：一般在数据表中加上一个数据版本号version字段，表示数据修改的次数，当数据修改时version+1。当线程A要更新数据的时候，在读取数据的同时也会把version读回来。处理完业务逻辑开始更新的时候，会再次查看version的值是否和数据库中version的值相等。如果相等更新。否则拒绝更新，你需要重新去读取version再次提交更新。

#### 2.1.1.2 JAVA CAS操作实现乐观锁 ####

CAS操作实现乐观锁：CAS(Compare and Seap 比较和交换)，当多个线程尝试使用CAS更新同一个变量的时候，只有其中一个线程能更新成功，其他线程都失败。这些失败的线程并不会被挂起，而是立马告之这次竞争操作失败。需要你自己去在次尝试。CAS操作中包含三个操作数：需要读取的内存位置(V)、进行比较的预期原值(A)、拟写入的新值(B)。如果内存位置对应的值(V)于预期原值(A)相匹配，那么处理器会自动将该内存位置的值更新为新值(B)，否则处理器不做任何操作。

JDK里面大量源码也是通过CAS来提供线程安全操作。在java.util.concurrent.atomic包下面。我们人为的把这个包里面的CAS实现线程安全操作分为两类：AtomicInteger、AtomicBoolean、AtomicLong、AtomicLongArray分为一类通过Unsafe实现乐观锁；AtomicIntegerFieldUpdater、AtomicLongFieldUpdater则是另一类他们要先通过反射获取到字段信息。接下来我们大概看下他们里面实现的原理。

##### 2.1.1.2.1 AtomicInteger #####

AtomicInteger、AtomicBoolean、AtomicLong、AtomicLongArray都是一样的，我们以AtomicInteger来讲。内部是通过Unsafe类来实现乐观锁。实现原理如下：

public class AtomicInteger extends Number implements java.io.Serializable {
    
        // unsafe来保证改变value的值是线程安全的
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        // value值的偏移量，static保证了所有的线程都同一份实例
        private static final long valueOffset;
    
        // 类初使化的时候通过unsafe能够得到变量的偏移量
        static {
            try {
                valueOffset = unsafe.objectFieldOffset
                        (AtomicInteger.class.getDeclaredField("value"));
            } catch (Exception ex) { throw new Error(ex); }
        }
    
        // 这里声明为volatile，保证了线程间的可见性。
        private volatile int value;
    
        ...
    
        /**
         * 设置新值，并且返回之前的值
         */
        public final int getAndSet(int newValue) {
            return unsafe.getAndSetInt(this, valueOffset, newValue);
        }
    
        ...
    
    }

getAndSet()函数调用的是Unsafe类里面的getAndSetInt()函数。

public final class Unsafe {
    
        ...
    
        /**
         * compareAndSwapInt函数里面会做几个步骤：
         * 1. 先获取内存中的值(getIntVolatile把值取出来)
         * 2. 和之前的值做比较
         * 3. 相同则更新，否则重试重新读直，在做这几个操作一直到成功
         */
        public final int getAndSetInt(Object var1, long var2, int var4) {
            int var5;
            do {
                var5 = this.getIntVolatile(var1, var2);
            } while(!this.compareAndSwapInt(var1, var2, var5, var4));
    
            return var5;
        }
    
        ...
    
    
    }

##### 2.1.1.2.1 AtomicIntegerFieldUpdater #####

AtomicIntegerFieldUpdater、AtomicLongFieldUpdater。可以对指定类的指定 volatile字段进行原子更新。他们是基于反射的实用工具，先通过反射得到需要操作的字段，之后统一是利用Unsafe类来实现CAS的操作。我们以AtomicIntegerFieldUpdater做实例说明。

public abstract class AtomicIntegerFieldUpdater<T> {
        /**
         * 定义AtomicIntegerFieldUpdater对象，两个参数第一个参数指定类，第二个参数类里面的某个字段
         * 主意里面返回的是AtomicIntegerFieldUpdaterImpl对想，我们直接看AtomicIntegerFieldUpdaterImpl对象
         */
        @CallerSensitive
        public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass,
                                                                  String fieldName) {
            return new AtomicIntegerFieldUpdaterImpl<U>
                    (tclass, fieldName, Reflection.getCallerClass());
        }
    
        ...
    
        /**
         * Standard hotspot implementation using intrinsics
         */
        private static class AtomicIntegerFieldUpdaterImpl<T>
                extends AtomicIntegerFieldUpdater<T> {
            // 通过Unsafe来实现CAS的操作
            private static final Unsafe unsafe = Unsafe.getUnsafe();
            // 传入filed的偏移量
            private final long offset;
            private final Class<T> tclass;
            private final Class<?> cclass;
    
            AtomicIntegerFieldUpdaterImpl(final Class<T> tclass,
                                          final String fieldName,
                                          final Class<?> caller) {
                final Field field;
                final int modifiers;
                try {
                    // 通过反射得到对应的Feld
                    field = AccessController.doPrivileged(
                            new PrivilegedExceptionAction<Field>() {
                                public Field run() throws NoSuchFieldException {
                                    return tclass.getDeclaredField(fieldName);
                                }
                            });
                    modifiers = field.getModifiers();
                    sun.reflect.misc.ReflectUtil.ensureMemberAccess(
                            caller, tclass, null, modifiers);
                    ClassLoader cl = tclass.getClassLoader();
                    ClassLoader ccl = caller.getClassLoader();
                    if ((ccl != null) && (ccl != cl) &&
                            ((cl == null) || !isAncestor(cl, ccl))) {
                        sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
                    }
                } catch (PrivilegedActionException pae) {
                    throw new RuntimeException(pae.getException());
                } catch (Exception ex) {
                    throw new RuntimeException(ex);
                }
    
                // 一定要是指定的类型
                Class<?> fieldt = field.getType();
                if (fieldt != int.class)
                    throw new IllegalArgumentException("Must be integer type");
    
                // 需要声明为volatile
                if (!Modifier.isVolatile(modifiers))
                    throw new IllegalArgumentException("Must be volatile type");
    
                this.cclass = (Modifier.isProtected(modifiers) &&
                        caller != tclass) ? caller : null;
                this.tclass = tclass;
                // 通过unsafe得到偏移量
                offset = unsafe.objectFieldOffset(field);
            }
            
        }
    }

通过分析代码我们发现AtomicIntegerFieldUpdater比我们上面分析的AtomicInteger多做了一步。他先通过反射拿到offset偏移量。怕有些人不知道AtomicIntegerFieldUpdater类怎么使用，一个简单的使用实例如下：

public static final AtomicIntegerFieldUpdater<Person> fieldUpdater = AtomicIntegerFieldUpdater.newUpdater(Person.class, "age");
    
        @Test
        public void atomicIntegerFieldUpdater() {
    
            // 可以在多个线程里面操作，线程安全
            Person person = new Person();
            fieldUpdater.set(person, 10);
    
        }
    
        class Person {
            private volatile int age;
    
            public int getAge() {
                return age;
            }
    
            public void setAge(int age) {
                this.age = age;
            }
        }

### 2.1.2 悲观锁 ###

悲观锁喜欢把所有的事情都往坏处想，认为一定存在很多并发更新操作。一定要采取加锁操作，如果不加锁一定会有问题。换句话说就是我在操作的时候阻止其他任何人做操作，一定要等我操作完了。你们才可以操作。比如：我们经常使用synchronized关键字来加锁。不管是修饰代码块还是修饰变量还是修饰方法。其实这个时候我们就用上悲观锁了(因为我们不管三七二十一，每次访问的时候，我们都认为有人会修改，我们每次访问的时候都锁住了)。

## 2.2 独享锁/共享锁 ##

独享锁是指该锁一次只能被一个线程所持有。共享锁是指该锁可以被多个线程所持有，可以多个线程访问。

*  独享锁：ReentrantLock、ReadWriteLock中的写锁、synchronized某种意义上来说也是独享锁。
 *  共享锁：Semaphore、CountDownLatch、ReadWriteLock中的读锁。

独享锁与共享锁是通过AQS(AbstractQueuedSynchronizer的简称)来实现的，通过实现不同的方法，来实现独享或者共享。AQS使用一个整型的volatile变量(命名为state)来维护同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。推荐大家去看下AbstractQueuedSynchronizer类的实现逻辑。

## 2.3 互斥锁/读写锁 ##

上面讲的独享锁/共享锁是一种广义的说法，互斥锁/读写锁就是他们的具体的实现。

*  互斥锁：和独享锁概念一样，同一时刻只能被一个线程访问。JAVA中的具体实现就是ReentrantLock。
 *  读写锁：同时持有读写锁，读写锁既是互斥锁，又是共享锁，read模式是共享，write是互斥(排它锁)的。JAVA中对应ReadWriteLock。

## 2.4 可重入锁 ##

可重入锁又叫递归锁，简单来说就是同一个线程可以多次获取锁。ReentrantLock和synchoronize都是可重入锁。

## 2.5 公平锁/非公平锁 ##

公平锁指的是多个线程按照申请的顺序来获取锁，非公平锁指的是多个线程获取锁的顺序不是按申请顺序来的。有可能造成优先级反转或者饥饿的现象。对于ReetrantLock而言我们可以通过构造函数来指定该锁是否公平锁。默认是非公平锁(非公平锁性能稍微高点，吞吐量稍微大一点)。Synchronized也是非公平锁。

## 2.6 分段锁 ##

分段锁是一种锁的设计，并不是具体的一种锁。在JDK1.7中ConcurrentHashMap采用了数组+Segment+分段锁的方式实现。ConcurrentHashMap使用分段锁技术，将数据分成一段一段的存储，然后给每一段数据配一把锁(每个Segment都是一个ReentrantLock)，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问，能够实现真正的并发访问。

我们用一个图来概况下ConcurrentHashMap的内部实现。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1eXV4aW5nMjQ_size_16_color_FFFFFF_t_70]

## 2.7 偏向锁/轻量级锁/重量级锁 ##

偏向锁/轻量级锁/重量级锁这三种锁是指锁的状态，并且是针对Synchronized。为了换取性能。在Java5通过引入锁升级的机制来实现高效Synchronized。这三种锁的状态是通过对象监视器在对象头中的字段来表明的。

*  偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。
 *  轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。
 *  重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让他申请的线程进入阻塞，性能降低。

## 2.8 自旋锁 ##

在Java中，自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

> 一个自旋锁的简单实现。

public class SpinLock {
    
        private final AtomicBoolean spinLock = new AtomicBoolean(true);
    
        /**
         * 获取锁
         */
        public void lock() {
            boolean flag;
            // 一直去获取锁
            do {
                // 只有当spinLock的值为true的时候,我们才可以获取成功，并且把值设置为false。
                flag = spinLock.compareAndSet(true, false);
            } while (!flag);
        }
    
        /**
         * 释放锁
         */
        public void unlock() {
            spinLock.compareAndSet(false, true);
        }
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1eXV4aW5nMjQ_size_16_color_FFFFFF_t_70]: /images/20211114/19a5ab01dede4776b92a4cd0ee0aca51.png