线程锁（二）锁的种类验证

心已赠人 2023-07-25 09:39 32阅读 0赞

[http://ifeve.com/java-art-reentrantlock/][http_ifeve.com_java-art-reentrantlock]

关键词：AQS、CAS、synchronized、ReentrantLock、ReentrantReadWriteLock

一、预备知识：

1、AQS：

AbstractQueuedSynchronized 抽象队列式的同步器，AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，如常用的ReentrantLock/Semaphore/CountDownLatch…

![format_png][]

AQS维护了一个volatile int state(代表共享资源)和一个FIFO线程等待队列（多线程争用资源被阻塞时会进入此队列）。

state的访问方式有三种： getState() 、setState() 、compareAndSetState()

AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）。

不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。自定义同步器实现时主要实现以下几种方法：

isHeldExclusively():该线程是否正在独占资源。只有用到condition才需要去实现它。
     tryAquire(int):独占方式。尝试获取资源，成功则返回true，失败则返回false。
     tryRelease(int):独占方式。尝试释放资源，成功则返回true，失败则返回false。
     tryAcquireShared(int):共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
     tryReleaseShared(int):共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其他线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多少次，这样才能保证state是能回到零态的。

再以CountDownLatch为例，任务分为N个子线程去执行，state为初始化为N（注意N要与线程个数一致）。这N个子线程是并行执行的，每个子线程执行完后countDown()一次，state会CAS减1。等到所有子线程都执行完后（即state=0），会unpark()主调用线程，然后主调用线程就会await()函数返回，继续后余动作。

一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如ReentrantReadWriteLock。

2、CAS：

CAS（Compare and Swap 比较并交换）是乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其他线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。

CAS操作中包含三个操作数——需要读写的内存位置（V）、进行比较的预期原值（A）和拟写入的新值（B）。如果内存位置V的值与预期原值A相匹配，那么处理器会自动将该位置值更新为新值B，否则处理器不做任何操作。无论哪种情况，它都会在CAS指令之前返回该位置的值（在CAS的一些特殊情况下将仅返回CAS是否成功，而不提取当前值）。CAS有效地说明了“我认为位置V应该包含值A；如果包含该值，则将B放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可”。这其实和乐观锁的冲突检查+数据更新的原理是一样的。

JAVA对CAS的支持：

在JDK1.5中新增java.util.concurrent包就是建立在CAS之上的。相对于synchronized这种阻塞算法，CAS是非阻塞算法的一种常见实现。所以java.util.concurrent包中的AtomicInteger为例，看一下在不使用锁的情况下是如何保证线程安全的。主要理解getAndIncrement方法，该方法的作用相当于++i操作。

public class AtomicInteger extends Number implements java.io.Serializable{
    　　private volatile int value;
    　　public final int get(){
    　　　　return value;
    　　}
    
    　 public final int getAndIncrement(){
    　　　　for (;;){
    　　　　　　int current = get();
    　　　　　　int next = current + 1;
    　　　　　　if (compareAndSet(current, next))
    　　　　　　return current;
    　　　　}
    　　}
     
    　　public final boolean compareAndSet(int expect, int update){
    　　　　return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    　　}
    }

3、ReentrantLock：既可以是公平锁，也可以是非公平锁，沟通构造函数实现，默认为非公平锁，查看源码构造公平锁只要在构造器传入boolean值true即可：

/**
         * Creates an instance of {@code ReentrantLock} with the
         * given fairness policy.
         *
         * @param fair {@code true} if this lock should use a fair ordering policy
         */
        public ReentrantLock(boolean fair) {
            sync = fair ? new FairSync() : new NonfairSync();
        }

二、验证：

1、synchronized：

public class MyLockTest implements Runnable {
        public synchronized void get() {
            System.out.println("2 enter thread name-->" + Thread.currentThread().getName());
            //reentrantLock.lock();
            System.out.println("3 get thread name-->" + Thread.currentThread().getName());
            set();
            //reentrantLock.unlock();
            System.out.println("5 leave run thread name-->" + Thread.currentThread().getName());
        }
    
        public synchronized void set() {
            //reentrantLock.lock();
            System.out.println("4 set thread name-->" + Thread.currentThread().getName());
            //reentrantLock.unlock();
        }
    
        @Override
        public void run() {
            System.out.println("1 run thread name-->" + Thread.currentThread().getName());
            get();
        }
    
        public static void main(String[] args) {
            MyLockTest test = new MyLockTest();
            for (int i = 0; i < 10; i++) {
                new Thread(test, "thread-" + i).start();
            }
        }
    
    }

一次运行结果：

1 run thread name-->thread-0
    2 enter thread name-->thread-0
    3 get thread name-->thread-0
    1 run thread name-->thread-1
    1 run thread name-->thread-2
    4 set thread name-->thread-0
    5 leave run thread name-->thread-0
    1 run thread name-->thread-3
    2 enter thread name-->thread-2
    3 get thread name-->thread-2
    4 set thread name-->thread-2
    5 leave run thread name-->thread-2
    2 enter thread name-->thread-1
    3 get thread name-->thread-1
    4 set thread name-->thread-1
    5 leave run thread name-->thread-1
    2 enter thread name-->thread-3
    3 get thread name-->thread-3
    4 set thread name-->thread-3
    5 leave run thread name-->thread-3
    1 run thread name-->thread-5
    2 enter thread name-->thread-5
    3 get thread name-->thread-5
    4 set thread name-->thread-5
    5 leave run thread name-->thread-5
    1 run thread name-->thread-7
    1 run thread name-->thread-6
    2 enter thread name-->thread-7
    3 get thread name-->thread-7
    4 set thread name-->thread-7
    1 run thread name-->thread-4
    5 leave run thread name-->thread-7
    1 run thread name-->thread-8
    2 enter thread name-->thread-8
    3 get thread name-->thread-8
    4 set thread name-->thread-8
    5 leave run thread name-->thread-8
    1 run thread name-->thread-9
    2 enter thread name-->thread-4
    3 get thread name-->thread-4
    4 set thread name-->thread-4
    5 leave run thread name-->thread-4
    2 enter thread name-->thread-6
    3 get thread name-->thread-6
    4 set thread name-->thread-6
    5 leave run thread name-->thread-6
    2 enter thread name-->thread-9
    3 get thread name-->thread-9
    4 set thread name-->thread-9
    5 leave run thread name-->thread-9

结论：

（a）get()方法中顺利进入了set()方法，说明synchronized的确是可重入锁；

（b）分析打印Log，thread-0先进入get方法体，这个时候thread-1、thread-2、thread-3等待进入，但当thread-0离开时，thread-2却先进入了方法体，没有按照thread-1、thread-2、thread-3的顺序进入get方法体，说明sychronized是非公平锁；

（c）而且在一个线程进入get方法体后，其他线程只能等待，无法同时进入，验证了synchronized是独占锁。

2、ReentrantLock：ReentrantLock首先是独享锁、可重入锁，其次既可以构造公平锁又可以构造非公平锁，默认为非公平锁

（1）例1：非公平锁

import java.util.concurrent.locks.ReentrantLock;
    
    public class MyLockTest implements Runnable {
    
        private ReentrantLock reentrantLock = new ReentrantLock();
    
        public void get() {
            System.out.println("2 enter thread name-->" + Thread.currentThread().getName());
            reentrantLock.lock();
            System.out.println("3 get thread name-->" + Thread.currentThread().getName());
            set();
            reentrantLock.unlock();
            System.out.println("5 leave run thread name-->" + Thread.currentThread().getName());
        }
    
        public void set() {
            reentrantLock.lock();
            System.out.println("4 set thread name-->" + Thread.currentThread().getName());
            reentrantLock.unlock();
        }
    
        @Override
        public void run() {
            System.out.println("1 run thread name-->" + Thread.currentThread().getName());
            get();
        }
    
        public static void main(String[] args) {
            MyLockTest test = new MyLockTest();
            for (int i = 0; i < 10; i++) {
                new Thread(test, "thread-" + i).start();
            }
        }
    
    }

一次运行结果：

1 run thread name-->thread-0
    2 enter thread name-->thread-0
    1 run thread name-->thread-1
    2 enter thread name-->thread-1
    3 get thread name-->thread-0
    4 set thread name-->thread-0
    1 run thread name-->thread-3
    2 enter thread name-->thread-3
    3 get thread name-->thread-3
    4 set thread name-->thread-3
    5 leave run thread name-->thread-3
    1 run thread name-->thread-4
    2 enter thread name-->thread-4
    3 get thread name-->thread-4
    4 set thread name-->thread-4
    5 leave run thread name-->thread-4
    1 run thread name-->thread-5
    2 enter thread name-->thread-5
    3 get thread name-->thread-5
    4 set thread name-->thread-5
    5 leave run thread name-->thread-5
    1 run thread name-->thread-7
    2 enter thread name-->thread-7
    3 get thread name-->thread-7
    4 set thread name-->thread-7
    5 leave run thread name-->thread-7
    5 leave run thread name-->thread-0
    3 get thread name-->thread-1
    4 set thread name-->thread-1
    5 leave run thread name-->thread-1
    1 run thread name-->thread-2
    2 enter thread name-->thread-2
    3 get thread name-->thread-2
    4 set thread name-->thread-2
    5 leave run thread name-->thread-2
    1 run thread name-->thread-9
    2 enter thread name-->thread-9
    3 get thread name-->thread-9
    4 set thread name-->thread-9
    5 leave run thread name-->thread-9
    1 run thread name-->thread-6
    1 run thread name-->thread-8
    2 enter thread name-->thread-8
    3 get thread name-->thread-8
    4 set thread name-->thread-8
    5 leave run thread name-->thread-8
    2 enter thread name-->thread-6
    3 get thread name-->thread-6
    4 set thread name-->thread-6
    5 leave run thread name-->thread-6

结论：

（a）可重入锁；

（b）独享锁：注意这个例子和synchronized的例子不一样，synchronized修饰的整个方法体都是锁的内容，所以可以从打印的enter、`leave的顺序分析是否为独享锁，而ReentrantLock只有lock()和unlock之间的内容为锁，所以只可以分析这段代码的顺序，比如分析打印的get、set的顺序；`

（c）非公平锁，thread-0持有锁期间，thread-1等待拥有锁，当thread-0释放锁时thread-3先获取到锁，并非按照先后顺序获取锁的。

（2）例2：公平锁：

上例的构造方法改为：ReentrantLock reentrantLock = new ReentrantLock(true);

一次运行结果为：

1 run thread name-->thread-0
    2 enter thread name-->thread-0
    3 get thread name-->thread-0
    1 run thread name-->thread-2
    2 enter thread name-->thread-2
    4 set thread name-->thread-0
    1 run thread name-->thread-3
    2 enter thread name-->thread-3
    1 run thread name-->thread-1
    2 enter thread name-->thread-1
    1 run thread name-->thread-5
    2 enter thread name-->thread-5
    3 get thread name-->thread-2
    4 set thread name-->thread-2
    5 leave run thread name-->thread-2
    5 leave run thread name-->thread-0
    3 get thread name-->thread-3
    4 set thread name-->thread-3
    5 leave run thread name-->thread-3
    1 run thread name-->thread-9
    2 enter thread name-->thread-9
    3 get thread name-->thread-1
    4 set thread name-->thread-1
    5 leave run thread name-->thread-1
    3 get thread name-->thread-5
    4 set thread name-->thread-5
    5 leave run thread name-->thread-5
    3 get thread name-->thread-9
    4 set thread name-->thread-9
    5 leave run thread name-->thread-9
    1 run thread name-->thread-6
    2 enter thread name-->thread-6
    3 get thread name-->thread-6
    4 set thread name-->thread-6
    1 run thread name-->thread-7
    5 leave run thread name-->thread-6
    2 enter thread name-->thread-7
    3 get thread name-->thread-7
    4 set thread name-->thread-7
    5 leave run thread name-->thread-7
    1 run thread name-->thread-4
    2 enter thread name-->thread-4
    3 get thread name-->thread-4
    1 run thread name-->thread-8
    2 enter thread name-->thread-8
    4 set thread name-->thread-4
    5 leave run thread name-->thread-4
    3 get thread name-->thread-8
    4 set thread name-->thread-8
    5 leave run thread name-->thread-8

3、ReentrantReadWriteLock：ReadWriteLock的实现类

读写锁的性能都会比排他锁要好，因为大多数场景读是多于写的。在读多于写的情况下，读写锁能够提供比排它锁更好的并发性和吞吐量。Java并发包提供读写锁的实现是ReentrantReadWriteLock。

<table> 
 <tbody> 
  <tr> 
   <td>特性</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>公平性选择</td> 
   <td>支持非公平(默认)和公平的锁获取方式，吞吐量还是非公平优于公平</td> 
  </tr> 
  <tr> 
   <td>重进入</td> 
   <td>该锁支持重进入，以读写线程为例：读线程在获取了读锁之后，能够再次获取读锁。而写线程在获取了写锁之后能够再次获取写锁，同时也可以获取读锁</td> 
  </tr> 
  <tr> 
   <td>锁降级</td> 
   <td>遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级成为读锁</td> 
  </tr> 
 </tbody> 
</table>

例：

import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class MyLockTest {
    
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Cache.put("key", new String(Thread.currentThread().getName() + " joke"));
                    }
                }, "threadW-" + i).start();
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Cache.get("key"));
                    }
                }, "threadR-" + i).start();
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Cache.clear();
                    }
                }, "threadC-" + i).start();
            }
        }
    }
    
    class Cache {
        static Map<String, Object> map = new HashMap<String, Object>();
        static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
        static Lock r = rwl.readLock();
        static Lock w = rwl.writeLock();
    
        // 获取一个key对应的value
        public static final Object get(String key) {
            r.lock();
            try {
                System.out.println("get " + Thread.currentThread().getName());
                return map.get(key);
            } finally {
                r.unlock();
            }
        }
    
        // 设置key对应的value，并返回旧有的value
        public static final Object put(String key, Object value) {
            w.lock();
            try {
                System.out.println("put " + Thread.currentThread().getName());
                return map.put(key, value);
            } finally {
                w.unlock();
            }
        }
    
        // 清空所有的内容
        public static final void clear() {
            w.lock();
            try {
                System.out.println("clear " + Thread.currentThread().getName());
                map.clear();
            } finally {
                w.unlock();
            }
        }
    }

运行结果：

put threadW-0
    clear threadC-1
    put threadW-1
    get threadR-1
    threadW-1 joke
    put threadW-2
    get threadR-0
    threadW-2 joke
    clear threadC-0
    get threadR-2
    null
    clear threadC-4
    clear threadC-2
    clear threadC-3
    put threadW-4
    put threadW-3
    get threadR-3
    threadW-3 joke
    put threadW-5
    get threadR-4
    threadW-5 joke
    clear threadC-5
    put threadW-6
    put threadW-7
    get threadR-7
    threadW-7 joke
    get threadR-5
    threadW-7 joke
    get threadR-6
    threadW-7 joke
    clear threadC-6
    clear threadC-7
    put threadW-8
    clear threadC-8
    put threadW-9
    get threadR-9
    threadW-9 joke
    clear threadC-9
    get threadR-8
    null

可看到普通HashMap在多线程中数据可见性正常。

[http_ifeve.com_java-art-reentrantlock]: http://ifeve.com/java-art-reentrantlock/
[format_png]: /images/20230528/c90f3eff9a12452aafe3e89abfd3c34f.png