Java中常见的锁

迈不过友情╰ 2023-01-22 06:54 15阅读 0赞

# 常见的锁 #

*  公平锁/非公平锁
 *  可重入锁
 *  独享锁/共享锁
 *  互斥锁/读写锁
 *  乐观锁/悲观锁
 *  分段锁
 *  偏向锁/轻量级锁/重量级锁
 *  自旋锁

上面是很多锁的名词，这些分类并不是全是指锁的状态，有的指锁的特性，有的指锁的设计，下面总结的内容是对每个锁的名词进行一定的解释。

# 公平锁、非公平锁 #

> **公平锁：**线程**获取锁的顺序是按照线程申请锁的顺序来分配**的，即先来先得的FIFO先进先出顺序。  
> **非公平锁：**指多个线程**获取锁的顺序并不是按照申请锁的顺序**，有可能**后申请的线程比先申请的线程优先获取锁**。有可能，会造成**优先级反转**或者**饥饿**现象。  
> 对于Java **`ReentrantLock`**而言，通过构造函数指定**该锁是否是公平锁，默认是非公平锁**。**非公平锁的优点在于吞吐量比公平锁大**。  
> 对于**`Synchronized`**而言，也是一种**非公平锁**。由于其并不像**`ReentrantLock`**是通过**AQS**的来实现线程调度，所以并没有任何办法使其变成公平锁。

ReentrantLock  写一个demo演示公平锁与非公平锁

**非公平锁**

package cn.com.boco.HermesService;
    import java.util.concurrent.locks.ReentrantLock;
    public class Demo {
        public static void main(String[] args) throws InterruptedException {
            final Service service = new Service(false);//true为公平锁，false为非公平锁
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程" + Thread.currentThread().getName()
                            + "运行了");
                    service.serviceMethod();
                }
            };
            Thread[] threadArray = new Thread[10];//创建一个数组
            //创建10个线程
            for (int i = 0; i < 10; i++) {
                threadArray[i] = new Thread(runnable);
            }
            //启动这10个线程
            for (int i = 0; i < 10; i++) {
                threadArray[i].start();
            }
        }
        //创建一个Service类。其中serviceMethod用ReentrantLock加锁
        static public class Service {
            private ReentrantLock lock;
            public Service(boolean isFair) {
                super();
                lock = new ReentrantLock(isFair);
            }
            public void serviceMethod() {
                lock.lock();
                try {
                    System.err.println("ThreadName=" + Thread.currentThread().getName()
                            + "获得锁定");
                } finally {
                    lock.unlock();
                }
            }
    
        }
    }

运行结果：

![20210518173314875.png][]

看结果获取锁的顺序是：4--0--7--5--3--1--8--6--9--2

线程的执行顺序是：4--2--0--7--5--3--1--8--6--9

当然非公平这种，运行很多次，也会出现申请锁的顺序和执行的顺序一致

**公平锁**

package cn.com.boco.HermesService;
    import java.util.concurrent.locks.ReentrantLock;
    public class Demo {
        public static void main(String[] args) throws InterruptedException {
            final Service service = new Service(true);//true为公平锁，false为非公平锁
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程" + Thread.currentThread().getName()
                            + "运行了");
                    service.serviceMethod();
                }
            };
            Thread[] threadArray = new Thread[10];//创建一个数组
            //创建10个线程
            for (int i = 0; i < 10; i++) {
                threadArray[i] = new Thread(runnable);
            }
            //启动这10个线程
            for (int i = 0; i < 10; i++) {
                threadArray[i].start();
            }
        }
        //创建一个Service类。其中serviceMethod用ReentrantLock加锁
        static public class Service {
            private ReentrantLock lock;
            public Service(boolean isFair) {
                super();
                lock = new ReentrantLock(isFair);
            }
            public void serviceMethod() {
                lock.lock();
                try {
                    System.err.println("ThreadName=" + Thread.currentThread().getName()
                            + "获得锁定");
                } finally {
                    lock.unlock();
                }
            }
    
        }
    }

运行结果：

![20210518173859995.png][]

申请锁的顺序：1--2--0--3--4--5--7--8--6--9

执行的顺序：1--2--0--3--4--5--7--8--6--9

# 可重入锁 #

**可重入锁**又名**递归锁**，指的是**同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。**  
在 JAVA 环境下 ReentrantLock 和 synchronized 都是 可重入锁。当然有可重入锁就有不可重入锁,不可重入锁就是**同一线程 外层函数获得锁之后 ,只能当前函数使用**。

可重入锁的一个好处是可一定程度避免死锁。

**可重入锁的原理**

> 每一个锁关联一个线程的持有者和计数器，当计数器为0时表示该锁没有被任何线程所持有，那么任何线程都可能获得该锁而调用相应的方法。
> 
> 当某一个线程请求成功后，JVM会记下锁的持有线程，并且计数器做+1，此时其它线程请求该锁，则必须等待；而持有该锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会再次+1(递增)。
> 
> 当线程退出同步代码块时，计数器会-1(递减)，如果计数器等0，则释放该锁。

**synchronized 可重入锁demo：**

class Demo{
        public synchronized void method1() {
            method2();
        }
        public synchronized void method2() {
             //........
        }
    }

**ReentrantLock 可重入锁demo：**

package cn.com.boco.HermesService;
    import java.util.concurrent.locks.ReentrantLock;
    public class Demo {
        public static void main(String[] args) {
    		new TestReentrantLock().method1();
    	} 
    }
    
    class TestReentrantLock  {
        ReentrantLock reentrantLock = new ReentrantLock();
        public void method1() {
            reentrantLock.lock();
            try {
                System.out.println("==>进入method1方法");
                System.out.println("==>准备调用method2");
                method2();
                Thread.sleep(2000);
            } catch (Exception e) {
            e.printStackTrace();
            } finally {
                reentrantLock.unlock();
                System.out.println("==>释放锁1");
            }
        }
        public void method2() {
            reentrantLock.lock();
            try {
                System.out.println("-->进入method2");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();
                System.out.println("-->释放锁2");
            }
        }
    }

运行结果：

![20210518182754882.png][]

由结果可以看出，进入method1获得锁后，并没有释放锁，又进入了method2,再次拿到同一个锁对象。

# 独享锁/共享锁 #

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

对于Java **`ReentrantLock`**而言，其是**独享锁**。但是对于Lock的另一个实现类**`ReadWriteLock`，其读锁是共享锁，其写锁是独享锁**。  
读锁的共享锁可保证并发读是非常高效的，读写，写读 ，写写的过程是互斥的。  
独享锁与共享锁也是通过AQS来实现的，通过实现不同的方法，来实现独享或者共享。  
对于`Synchronized`而言，当然是独享锁。

# 互斥锁/读写锁 #

上面讲的独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。  
互斥锁在Java中的具体实现就是**`ReentrantLock`**  
读写锁在Java中的具体实现就是**`ReadWriteLock`**

# 乐观锁/悲观锁 #

乐观锁与悲观锁不是指具体的什么类型的锁，而是指看待并发同步的角度。  
**悲观锁**认为对于同一个数据的并发操作，一定是会发生修改的，哪怕没有修改，也会认为修改。因此对于同一个数据的并发操作，悲观锁采取加锁的形式。悲观的认为，不加锁的并发操作一定会出问题。  
**乐观锁**则认为对于同一个数据的并发操作，是不会发生修改的。在更新数据的时候，会采用尝试更新，不断重新的方式更新数据。乐观的认为，不加锁的并发操作是没有事情的。

从上面的描述我们可以看出，悲观锁适合写操作非常多的场景，乐观锁适合读操作非常多的场景，不加锁会带来大量的性能提升。  
悲观锁在Java中的使用，就是利用各种锁。  
乐观锁在Java中的使用，是无锁编程，常常采用的是CAS算法，典型的例子就是原子类，通过CAS自旋实现原子操作的更新。

# 分段锁 #

分段锁其实是一种锁的设计，并不是具体的一种锁，对于**`ConcurrentHashMap`**而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。  
我们以**`ConcurrentHashMap`**来说一下分段锁的含义以及设计思想，`ConcurrentHashMap`中的分段锁称为Segment，它即类似于HashMap（JDK7与JDK8中HashMap的实现）的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表；同时又是一个ReentrantLock（Segment继承了ReentrantLock)。  
当需要put元素的时候，并不是对整个hashmap进行加锁，而是先通过hashcode来知道他要放在那一个分段中，然后对这个分段进行加锁，所以当多线程put的时候，只要不是放在一个分段中，就实现了真正的并行的插入。  
但是，在统计size的时候，可就是获取hashmap全局信息的时候，就需要获取所有的分段锁才能统计。  
分段锁的设计目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。

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

这三种锁是指锁的状态，并且是针对`Synchronized`。在Java 5通过引入锁升级的机制来实现高效`Synchronized`。这三种锁的状态是通过对象监视器在对象头中的字段来表明的。  
**偏向锁**是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。  
**轻量级锁**是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。  
**重量级锁**是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。

# 自旋锁 #

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

[20210518173314875.png]: /images/20221020/acb40d1ea6c14bbc86dd328d22ef356e.png
[20210518173859995.png]: /images/20221020/a40d1a2e47a84f89b955a74cfb75a993.png
[20210518182754882.png]: /images/20221020/f5e4e7b6fca340b499600997c2af9fae.png