6.1 公平和非公平锁

6.1.1 是什么

  1. package s02.e06;
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  6. public class T1 {
  7.     volatile int n = 0;
  9.     public void add() {
  10.         n++;
  11.     }
  13.     public static void main(String[] args) {
  14.         Lock lock = new ReentrantLock();
  15.     }
  16. }

image.png
公平锁―是指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到。
非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后中请的线程比先中请的线程优先获取锁。
在高并发的情况下，有可能会造成优先级反转或者饥饿现象。

6.1.2 两者区别

  1. 公平锁：Threads acquire a fair lock in the order in which they requested it

公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照 FIFO 的规则从队列中取到自己

  1. 非公平锁：a nonfair lock permits barging: threads requesting a lock can jump ahead of the queue of waiting threads if the lockhappens to be available when it is requested.

非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁那种方式。

6.1.3 题外话

Java ReentrantLock，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。
Synchronized 也是一种非公平锁

6.2 可重入锁(又名递归锁)

6.1.1 是什么

指的是同一线程外层函数获得锁之后﹐内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。
也即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块。
ReentrantLock/Synchronized 就是一个典型的可重入锁
可重入锁最大的作用是避免死锁

6.1.2 Synchronized

  1. package s02.e06;
  3. class Phone {
  4.     public synchronized void sendSMS() throws Exception {
  5.         System.out.println(Thread.currentThread().getName() + "\t invoked sendSMS()");
  6.         sendEmail();
  7.     }
  9.     public synchronized void sendEmail() throws Exception {
  10.         System.out.println(Thread.currentThread().getName() + "\t #######invoked sendEmai()");
  11.     }
  12. }
  15. public class ReentrantLockDemo {
  16.     public static void main(String[] args) {
  17.         Phone phone = new Phone();
  19.         new Thread(() -> {
  20.             try {
  21.                 phone.sendSMS();
  22.             } catch (Exception e) {
  23.                 e.printStackTrace();
  24.             }
  25.         }, "t1").start();
  27.         new Thread(() -> {
  28.             try {
  29.                 phone.sendSMS();
  30.             } catch (Exception e) {
  31.                 e.printStackTrace();
  32.             }
  33.         }, "t2").start();
  35.     }
  36. }

image.png
通过上面示例我们可以看出，t1 线程在外层方法获取锁的时候，t1 在进入内层方法会自动获取锁

6.1.3 ReentrantLock

  1. package s02.e06;
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  6. class Phone implements Runnable {
  7.     Lock lock = new ReentrantLock();
  9.     @Override
  10.     public void run() {
  11.         get();
  12.     }
  14.     public void get() {
  15.         lock.lock();
  16.         try {
  17.             System.out.println(Thread.currentThread().getName() + "\t invoked get()");
  18.             set();
  19.         } finally {
  20.             lock.unlock();
  21.         }
  22.     }
  24.     public void set() {
  25.         lock.lock();
  26.         try {
  27.             System.out.println(Thread.currentThread().getName() + "\t #######invoked set()");
  28.         } finally {
  29.             lock.unlock();
  30.         }
  31.     }
  32. }
  35. public class ReentrantLockDemo {
  36.     public static void main(String[] args) {
  37.         Phone phone = new Phone();
  39.         Thread t3 = new Thread(phone, "t3");
  40.         Thread t4 = new Thread(phone, "t4");
  42.         t3.start();
  43.         t4.start();
  44.     }
  45. }

image.png

  1. package s02.e06;
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  6. class Phone implements Runnable {
  7.     Lock lock = new ReentrantLock();
  9.     @Override
  10.     public void run() {
  11.         get();
  12.     }
  14.     public void get() {
  15.         lock.lock();
  16.         lock.lock(); // 多加一层锁
  17.         try {
  18.             System.out.println(Thread.currentThread().getName() + "\t invoked get()");
  19.             set();
  20.         } finally {
  21.             lock.unlock();
  22.             lock.unlock();
  23.         }
  24.     }
  26.     public void set() {
  27.         lock.lock();
  28.         try {
  29.             System.out.println(Thread.currentThread().getName() + "\t #######invoked set()");
  30.         } finally {
  31.             lock.unlock();
  32.         }
  33.     }
  34. }
  37. public class ReentrantLockDemo {
  38.     public static void main(String[] args) {
  39.         Phone phone = new Phone();
  41.         Thread t3 = new Thread(phone, "t3");
  42.         Thread t4 = new Thread(phone, "t4");
  44.         t3.start();
  45.         t4.start();
  46.     }
  47. }

image.png
多加一层锁也是可以的，只要加锁跟解锁次数匹配即可

6.3 自旋锁(spinlock)

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

通过 CAS 操作完成自旋锁，A 线程先进来调用 myLock 方法自己持有锁 5 秒钟，B 随后进来后发现当前有线程持有锁，不是 null，所以只能通过自旋等待，直到 A 释放锁后B随后抢到。

  1. package s02.e06;
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.atomic.AtomicReference;
  6. public class SpinLockDemo {
  8.     // 原子引用线程
  9.     AtomicReference<Thread> atomicReference = new AtomicReference<>();
  11.     public void myLock() {
  12.         Thread thread = Thread.currentThread();
  13.         System.out.println(Thread.currentThread().getName() + "\t come in o(n_n)o");
  14.         while (!atomicReference.compareAndSet(null, thread)) {
  15.         }
  16.     }
  18.     public void myUnlock() {
  19.         Thread thread = Thread.currentThread();
  20.         atomicReference.compareAndSet(thread, null);
  21.         System.out.println(Thread.currentThread().getName() + "\t invoked myUnLock()");
  22.     }
  24.     public static void main(String[] args) {
  25.         SpinLockDemo spinLockDemo = new SpinLockDemo();
  26.         new Thread(() -> {
  27.             spinLockDemo.myLock();
  28.             // 暂停一会儿线程
  29.             try {
  30.                 TimeUnit.SECONDS.sleep(5);
  31.             } catch (InterruptedException e) {
  32.                 e.printStackTrace();
  33.             }
  34.             spinLockDemo.myUnlock();
  35.         }, "AA").start();
  37.         try {
  38.             TimeUnit.SECONDS.sleep(1);
  39.         } catch (InterruptedException e) {
  40.             e.printStackTrace();
  41.         }
  43.         new Thread(() -> {
  44.             spinLockDemo.myLock();
  45.             try {
  46.                 TimeUnit.SECONDS.sleep(1);
  47.             } catch (InterruptedException e) {
  48.                 e.printStackTrace();
  49.             }
  50.             spinLockDemo.myUnlock();
  51.         }, "BB").start();
  52.     }
  53. }

image.png

6.4 独占锁(写锁)/共享锁(读锁)/互斥锁

独占锁：指该锁一次只能被一个线程所持有。对 ReentrantLock 和 Synchronized 而言都是独占锁
共享锁：指该锁可被多个线程所持有。对 ReentrantReadWriteLock 其读锁是共享锁，其写锁是独占锁。
读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。
多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。但是如果有一个线程想去写共享资源来，就不应该再有其它线程可以对该资源进行读或写
小总结：

  • 读-读能共存
  • 读-写不能共存
  • 写-写不能共存
  • 写操作：原子 + 独占，整个过程必须是一个完整的统一体，中间不许被分割，被打断 ```java package s02.e06;

import java.util.HashMap; import java.util.Map; import java.util.concurrent.TimeUnit;

// 资源类 class Mycache { private volatile Map map = new HashMap<>();

  1. // private Lock lock=new ReentrantLock();
  2. public void put(String key, Object value) {
  3.     System.out.println(Thread.currentThread().getName() + "\t 正在写入: " + key);
  4.     // 暂停一会儿线程
  5.     try {
  6.         TimeUnit.MILLISECONDS.sleep(300);
  7.     } catch (InterruptedException e) {
  8.         e.printStackTrace();
  9.     }
  10.     map.put(key, value);
  11.     System.out.println(Thread.currentThread().getName() + "\t写入完成了");
  12. }
  14. public void get(String key) {
  15.     System.out.println(Thread.currentThread().getName() + "\t正在读取:");
  16.     // 暂停一会儿线程
  17.     try {
  18.         TimeUnit.MILLISECONDS.sleep(300);
  19.     } catch (InterruptedException e) {
  20.         e.printStackTrace();
  21.     }
  22.     Object result = map.get(key);
  23.     System.out.println(Thread.currentThread().getName() + "\t 读取完成:" + result);
  24. }

}

public class ReadWriteLockDemo { public static void main(String[] args) { Mycache mycache = new Mycache();

  1.     for (int i = 0; i < 5; i++) {
  2.         final int tempInt = i;
  3.         new Thread(() -> {
  4.             mycache.put(tempInt + "", tempInt + "");
  5.         }, String.valueOf(i)).start();
  6.     }
  8.     for (int i = 0; i < 5; i++) {
  9.         final int tempInt = i;
  10.         new Thread(() -> {
  11.             mycache.get(tempInt + "");
  12.         }, String.valueOf(i)).start();
  13.     }
  14. }

}

  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/390086/1644732885158-8f03e825-3ff1-4aa0-b17c-4dfcdf960eb3.png#clientId=u227a32c3-c034-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=445&id=u3f2dcee6&margin=%5Bobject%20Object%5D&name=image.png&originHeight=445&originWidth=156&originalType=binary&ratio=1&rotation=0&showTitle=false&size=10806&status=done&style=none&taskId=u76d0a7f1-ddd6-403d-b1a9-347e3566e3f&title=&width=156)<br />在不加锁的情况下，写入操作被打断，完全违背了原子性
  2. ```java
  3. package s02.e06;
  5. import java.util.HashMap;
  6. import java.util.Map;
  7. import java.util.concurrent.TimeUnit;
  8. import java.util.concurrent.locks.ReentrantReadWriteLock;
  10. // 资源类
  11. class Mycache {
  12.     private volatile Map<String, Object> map = new HashMap<>();
  13.     private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
  15.     // private Lock lock=new ReentrantLock();
  16.     public void put(String key, Object value) {
  17.         rwLock.writeLock().lock();
  18.         try {
  19.             System.out.println(Thread.currentThread().getName() + "\t 正在写入: " + key);
  20.             // 暂停一会儿线程
  21.             try {
  22.                 TimeUnit.MILLISECONDS.sleep(300);
  23.             } catch (InterruptedException e) {
  24.                 e.printStackTrace();
  25.             }
  26.             map.put(key, value);
  27.             System.out.println(Thread.currentThread().getName() + "\t写入完成了");
  28.         } catch (Exception e) {
  29.             e.printStackTrace();
  30.         } finally {
  31.             rwLock.writeLock().unlock();
  32.         }
  33.     }
  35.     public void get(String key) {
  36.         rwLock.readLock().lock();
  37.         try {
  38.             System.out.println(Thread.currentThread().getName() + "\t正在读取:");
  39.             // 暂停一会儿线程
  40.             try {
  41.                 TimeUnit.MILLISECONDS.sleep(300);
  42.             } catch (InterruptedException e) {
  43.                 e.printStackTrace();
  44.             }
  45.             Object result = map.get(key);
  46.             System.out.println(Thread.currentThread().getName() + "\t 读取完成:" + result);
  47.         } catch (Exception e) {
  48.             e.printStackTrace();
  49.         } finally {
  50.             rwLock.readLock().unlock();
  51.         }
  52.     }
  53. }
  56. public class ReadWriteLockDemo {
  57.     public static void main(String[] args) {
  58.         Mycache mycache = new Mycache();
  60.         for (int i = 0; i < 5; i++) {
  61.             final int tempInt = i;
  62.             new Thread(() -> {
  63.                 mycache.put(tempInt + "", tempInt + "");
  64.             }, String.valueOf(i)).start();
  65.         }
  67.         for (int i = 0; i < 5; i++) {
  68.             final int tempInt = i;
  69.             new Thread(() -> {
  70.                 mycache.get(tempInt + "");
  71.             }, String.valueOf(i)).start();
  72.         }
  73.     }
  74. }

image.png
通过读写锁，保证写入操作的原子性和读取操作的高并发性