多线程和高并发(三)

喜欢ヅ旅行 2022-12-22 11:07 171阅读 0赞

### 公平锁和非公平锁 ###

*  公平锁是指多个线程按照申请锁的顺序来获取锁
 *  非公平锁，是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，多个线程争夺锁。在高并发情况下，有可能会造成优先级反转或者饥饿现象。

reentranlock和synchronized默认是非公平锁。

### 可重入锁和递归锁 ###

可重入锁又名递归锁，指的是同一线程外层函数获得锁后，内层递归函数仍然能获得该锁的代码，即线程可以进入任何一个它已经拥有的锁，所同步着得代码块。

可重入锁最大的作用是避免死锁。

reentranlock和synchronized也是可重入锁。

### 自旋锁 ###

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

实现一个自旋锁

import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicReference;
    
    /**
     * @author wardseptember
     * @create 2020-09-21 21:25
     */
    public class SpinLockDemo {
        
        AtomicReference<Thread> atomicReference = new AtomicReference<>();
    
        public void lock() {
        
            Thread thread = Thread.currentThread();
            System.out.println(thread.getName()+"\t come in");
            while (!atomicReference.compareAndSet(null, thread)) {
        
    
            }
        }
    
        public void unLock() {
        
            Thread thread = Thread.currentThread();
            atomicReference.compareAndSet(thread, null);
            System.out.println(thread.getName()+"\t invoked myUnlock");
        }
    
        public static void main(String[] args) {
        
            SpinLockDemo spinLockDemo = new SpinLockDemo();
            new Thread(() -> {
        
                spinLockDemo.lock();
                try {
        
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                spinLockDemo.unLock();
            },"thread1").start();
    
            try {
        
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            new Thread(() -> {
        
                spinLockDemo.lock();
                spinLockDemo.unLock();
            }, "thread2").start();
    
    
        }
    }

### 独占锁和共享锁 ###

*  独占锁是指改锁一次只能被一个线程所持有
 *  共享锁指该锁可被多个线程所持有

ReentrantLock和Synchronized都是独占锁；ReentrantReadWriteLock其读锁是共享锁，其写锁是独占锁。

读写锁使用演示：

import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /**
     * @author wardseptember
     * @create 2020-09-21 23:31
     */
    
    
    class MyCache {
        
        private volatile Map<String, Object> map = new HashMap<>();
        private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        public void put(String key, Object value) {
        
            rwLock.writeLock().lock();
            try {
        
                System.out.println(Thread.currentThread().getName()+"\t 正在写入：" + key);
                try {
        
                    TimeUnit.MICROSECONDS.sleep(300);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }            map.put(key, value);
                System.out.println(Thread.currentThread().getName()+"\t 写入完成");
            } catch (Exception e){
        
                e.printStackTrace();
            } finally {
        
                rwLock.writeLock().unlock();
            }
        }
        public Object get(String key) {
        
            rwLock.readLock().lock();
            try {
        
                System.out.println(Thread.currentThread().getName()+"\t 正在读取");
                try {
        
                    TimeUnit.MICROSECONDS.sleep(300);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                Object result = map.get(key);
                System.out.println(Thread.currentThread().getName()+"\t 正在读取: "+result);
                return result;
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                rwLock.readLock().unlock();
            }
            return null;
        }
    
        public void clearMap() {
        
            map.clear();
        }
    }
    public class ReadWriteLockDemo {
        
        public static void main(String[] args) {
        
            MyCache myCache = new MyCache();
            for (int i = 0; i < 5; i++) {
        
                final int keyValue = i;
                new Thread(() -> {
        
                    myCache.put(keyValue+"", keyValue+ "");
                }, i+"").start();
            }
    
            for (int i = 0; i < 5; i++) {
        
                final int keyValue = i;
                new Thread(() -> {
        
                    myCache.get(keyValue+"");
                }, i+"").start();
            }
        }
    }

### 乐观锁、悲观锁 ###

#### 乐观锁 ####

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write\_condition机制，其实都是提供的乐观锁。在Java中`java.util.concurrent.atomic`包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

#### 悲观锁 ####

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中`synchronized`和`ReentrantLock`等独占锁就是悲观锁思想的实现。

#### 两种锁的使用场景 ####

从上面对两种锁的介绍，我们知道两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。

#### 乐观锁常见的实现方式 ####

##### 版本号机制 #####

一般是在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据被修改时，version值会加一。当线程A要更新数据值时，在读取数据的同时也会读取version值，在提交更新时，若刚才读取到的version值为当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功。

##### CAS #####

在修改之前，会有一个期望值，和要修改的值，如果期望值和我们设想的不一样，就不修改；如果一样就修改该值。CAS修改操作有CPU原语支持，中间不能中断，保存结果无误。

#### 乐观锁缺点 ####

1.  ABA 问题

如果一个变量V初次读取的时候是A值，并且在准备赋值的时候检查到它仍然是A值，那我们就能说明它的值没有被其他线程修改过了吗？很明显是不能的，因为在这段时间它的值可能被改为其他值，然后又改回A，那CAS操作就会误认为它从来没有被修改过。这个问题被称为CAS操作的 "ABA"问题。

JDK 1.5 以后的 `AtomicStampedReference 类`就提供了此种能力，其中的 `compareAndSet 方法`就是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

1.  循环时间长开销大

自旋CAS（也就是不成功就一直循环执行直到成功）如果长时间不成功，会给CPU带来非常大的执行开销。 如果JVM能支持处理器提供的pause指令那么效率会有一定的提升，pause指令有两个作用，第一它可以延迟流水线执行指令（de-pipeline）,使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突（memory order violation）而引起CPU流水线被清空（CPU pipeline flush），从而提高CPU的执行效率。

1.  只能保证一个共享变量的原子操作

CAS 只对单个共享变量有效，当操作涉及跨多个共享变量时 CAS 无效。但是从 JDK 1.5开始，提供了`AtomicReference类`来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行 CAS 操作.所以我们可以使用锁或者利用`AtomicReference类`把多个共享变量合并成一个共享变量来操作。

### CAS与synchronized的使用情景 ###

简单的来说CAS适用于写比较少的情况下（多读场景，冲突一般较少），synchronized适用于写比较多的情况下（多写场景，冲突一般较多）

*  对于资源竞争较少（线程冲突较轻）的情况，使用synchronized同步锁进行线程阻塞和唤醒切换以及用户态内核态间的切换操作额外浪费消耗cpu资源；而CAS基于硬件实现，不需要进入内核，不需要切换线程，操作自旋几率较少，因此可以获得更高的性能。
 *  对于资源竞争严重（线程冲突严重）的情况，CAS自旋的概率会比较大，从而浪费更多的CPU资源，效率低于synchronized。

补充： Java并发编程这个领域中synchronized关键字一直都是元老级的角色，很久之前很多人都会称它为 “重量级锁” 。但是，在JavaSE 1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的 偏向锁 和 轻量级锁 以及其它各种优化之后变得在某些情况下并不是那么重了。synchronized的底层实现主要依靠 Lock-Free 的队列，基本思路是 自旋后阻塞，竞争切换后继续竞争锁，稍微牺牲了公平性，但获得了高吞吐量。在线程冲突较少的情况下，可以获得和CAS类似的性能；而线程冲突严重的情况下，性能远高于CAS。

### 什么是自旋锁？ ###

自旋锁（spinlock）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。

获取锁的线程一直处于活跃状态，但是并没有执行任何有效的任务，使用这种锁会造成[busy-waiting][]。

### Synchronized优化 ###

Synchronized优化一般指的是同步代码块中代码语句越少越好，就是锁细化；还有一种是锁的粗化。

import java.util.concurrent.TimeUnit;
    
    
    public class FineCoarseLock {
        
       
       int count = 0;
    
       synchronized void m1() {
        
          //do sth need not sync
          try {
        
             TimeUnit.SECONDS.sleep(2);
          } catch (InterruptedException e) {
        
             e.printStackTrace();
          }
          //业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
          count ++;
          
          //do sth need not sync
          try {
        
             TimeUnit.SECONDS.sleep(2);
          } catch (InterruptedException e) {
        
             e.printStackTrace();
          }
       }
       
       void m2() {
        
          //do sth need not sync
          try {
        
             TimeUnit.SECONDS.sleep(2);
          } catch (InterruptedException e) {
        
             e.printStackTrace();
          }
          //业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
          //采用细粒度的锁，可以使线程争用时间变短，从而提高效率
          synchronized(this) {
        
             count ++;
          }
          //do sth need not sync
          try {
        
             TimeUnit.SECONDS.sleep(2);
          } catch (InterruptedException e) {
        
             e.printStackTrace();
          }
       }
    }

### Synchronized其他注意点 ###

1.  Synchronized锁定某对象o后，如果o的属性发生变化，不影响锁使用；但如果o变成另一个对象，则锁定的对象发生变化。应该避免将锁定对象的引用变成另外的对象。

public class SyncSameObject {
        
    
       /*final*/ Object o = new Object();
    
       void m() {
        
          synchronized(o) {
        
             while(true) {
        
                try {
        
                   TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
        
                   e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
             }
          }
       }
    
       public static void main(String[] args) {
        
          SyncSameObject t = new SyncSameObject();
          //启动第一个线程
          new Thread(t::m, "t1").start();
    
          try {
        
             TimeUnit.SECONDS.sleep(3);
          } catch (InterruptedException e) {
        
             e.printStackTrace();
          }
          //创建第二个线程
          Thread t2 = new Thread(t::m, "t2");
    
          // 锁对象发生改变，所以t2线程得以执行，如果注释掉这句话，线程2将永远得不到执行机会
          t.o = new Object(); 
    
          t2.start();
       }
    }

1.  Synchronized不能用于锁String常量、Integer、Long，容易出问题。
    
    在下面的例子中，m1和m2其实锁定的是同一个对象，这种情况还会发生比较诡异的现象，比如你用到了一个类库，在该类库中代码锁定了字符串“Hello”，但是你读不到源码，所以你在自己的代码中也锁定了"Hello",这时候就有可能发生非常诡异的死锁阻塞，因为你的程序和你用到的类库不经意间使用了同一把锁。

public class DoNotLockString {
        
    
       String s1 = "Hello";
       String s2 = "Hello";
    
       void m1() {
        
          synchronized(s1) {
        
    
          }
       }
    
       void m2() {
        
          synchronized(s2) {
        
    
          }
       }
    }

### CAS (Compare And Swap)/乐观锁/自旋锁 ###

CAS是原子操作，可以保证线程安全。

#### 使用 ####

下面代码无锁，也可以保证count最后结果是10000。

public class UseCAS {
        
        AtomicInteger count = new AtomicInteger();
        void m() {
        
            for (int i = 0; i < 10000; i++) {
        
                count.incrementAndGet(); // count++
            }
        }
    
        public static void main(String[] args) {
        
            UseCAS t = new UseCAS();
    
            List<Thread> threads = new ArrayList<Thread>();
    
            for (int i = 0; i < 10; i++) {
        
                threads.add(new Thread(t::m, "thread-" + i));
            }
    
            threads.forEach((o) -> o.start());
    
            threads.forEach((o) -> {
        
                try {
        
                    o.join();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            });
    
            System.out.println(t.count);
        }
    }

#### CAS原理 ####

##### Unsafe #####

是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地(native)方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据，Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存。Java中CAS操作的执行依赖于Unsafe类的方法。

##### 变量valueOffset #####

valueOffset表示该变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的。

变量value用volatile修饰，保证了多线程之间的内存可见性。

调用Unsafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令，这是一种完成依赖于硬件的功能，通过它实现了原子操作。由于CAS是一种系统原语，原语属于操作系统用语范畴，是由于若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是锁CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。

#### 注意 ####

ABA问题指如果期望值是A，操作之前被改成B，又改回A。如果是基础类型，没有影响；如果是引用类型，可能会有问题。

ABA问题可以用版本号解决，使用AtmoicStampedReference类。

### LongAdder ###

分段锁

### 可重入锁 ###

同一个线程内，锁可重入，就是可以再加一把锁，实际上没有加，而是直接调用。

可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。

reentrantlock可用于替代synchronized，它比synchronized的功能更强大。

[busy-waiting]: https://en.wikipedia.org/wiki/Busy_waiting