Java 锁的理解

た入场券 2022-11-25 10:25 60阅读 0赞

### 文章目录 ###

*  公平锁与非公平锁
 *   *  非公平锁
     *  公平锁
     *  关于公平锁与非公平锁的区别
 *  可重入锁（也叫作递归锁）
 *   *  举例
 *  自旋锁
 *   *  自旋锁的好处
     *  举例
 *  独占锁（写锁）/共享锁（读锁）/互斥锁
 *   *  举例（未使用读写锁）
     *  举例（使用读写锁）

# 公平锁与非公平锁 #

用过并发包的朋友对这个应该不会陌生，ReentrantLock 是 Java 的 JUC（java.util.concurrent）包中提供的一种可重入锁，是一种递归无阻塞的同步机制。ReentrantLock 等同于synchronized关键字，但是 ReentrantLock 提供了比 synchronized 更强大，更灵活的锁机制，可以减少死锁发生的概率

![在这里插入图片描述][2020041120174359.png]

## 非公平锁 ##

ReentrantLock 还提供了公平锁（fair）和非公平锁（unfair）。非公平锁是当锁被释放的时候，等待中的线程均有机会获得锁。有可能后申请的线程比先申请的线程优先获取锁，在高并发的情况下，有可能会造成优先级反转或者饥饿现象synchronized是非公平锁，而 ReentrantLock 也是一样。但是 ReentrantLock 可以通过构造方法接收一个可选的fair参数（默认是非公平锁）  
![在这里插入图片描述][20200411202131268.png]

## 公平锁 ##

所谓的公平锁就是指锁的获取策略相对公平，当多个线程在获取同一个锁的时候，必须按照锁的申请时间来一次获得锁，也就是按顺序来

![在这里插入图片描述][2020041120225522.png]  
当传入的值为 true 时则表示是公平锁，源码如下：  
![在这里插入图片描述][20200411202243377.png]

## 关于公平锁与非公平锁的区别 ##

*  **公平锁**：就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当线程是等待队列的第一个，就占有锁。否则就会加入到等待队列中，以后会按照 FIFO（先进先出原则）从队列中获取到自己
 *  **非公平锁**：非公平比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁的那种方式

--------------------

对于 ReentrantLock 而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大

对于 synchronized 而言，也是一种非公平锁

# 可重入锁（也叫作递归锁） #

指的是同一个线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁

简单地说，线程可以进入任何一个它已经拥有的锁所同步着的代码块

## 举例 ##

package concurrency.day0411;
    
    /** * @author Woo_home * @create by 2020/4/11 20:06 */
    
    // 线程操纵资源类
    class ThreadDemo { 
    	// 定义一个同步方法
        public synchronized void seyHello() { 
            System.out.println(Thread.currentThread().getName() + " say Hello");
            // 在同步方法内调用另一个同步方法
            seyHi();
        }
        // 定义一个同步方法（被另一个同步方法调用的同步方法）
        public synchronized void seyHi() { 
            System.out.println(Thread.currentThread().getName() + " say Hi");
        }
    }
    
    public class ReentrantLockDemo { 
        public static void main(String[] args) { 
            ThreadDemo demo = new ThreadDemo();
            new Thread(() -> { 
                demo.seyHello();
            },"T1").start();
    
            new Thread(() -> { 
                demo.seyHello();
            },"T2").start();
        }
    }

输出：  
![在这里插入图片描述][20200411201043326.png]

# 自旋锁 #

是指尝试获取锁的线程不会立即阻塞，而是 采用循环的方式去尝试获取锁，这样的好处是减少线程上下文的切换的消耗，缺点是循环会消耗 CPU  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70]

## 自旋锁的好处 ##

循环比较获取直到成功为止，没有类似 wait 的阻塞

## 举例 ##

package concurrency.day0411;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicReference;
    
    /** * @author Woo_home * @create by 2020/4/11 20:42 */
    public class CASDemo { 
    
        // 原子引用线程
        AtomicReference<Thread> atomicReference = new AtomicReference<>();
    
        public void myLock() { 
            Thread thread = Thread.currentThread();
            System.out.println(Thread.currentThread().getName() + "\t come in");
            while (!atomicReference.compareAndSet(null,thread)) { 
    
            }
        }
    
        public void myUnLock() { 
            Thread thread = Thread.currentThread();
            atomicReference.compareAndSet(thread,null);
            System.out.println(Thread.currentThread().getName() + "\t invoked myUnLock()");
        }
    
        public static void main(String[] args) { 
            CASDemo casDemo = new CASDemo();
    
            new Thread(() -> { 
                casDemo.myLock();
                try { 
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                casDemo.myUnLock();
            },"A").start();
    
            try { 
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            new Thread(() -> { 
                casDemo.myLock();
                try { 
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                casDemo.myUnLock();
            },"B").start();
        }
    }

输出：  
![在这里插入图片描述][2020041212102040.png]

# 独占锁（写锁）/共享锁（读锁）/互斥锁 #

*  **独占锁（写锁）**：指的是该锁一次只能被一个线程所持有。对 ReentrantLock 和 synchronized 而言都是独占锁
 *  **共享锁（读锁）**：指的是该锁可被多个线程锁持有。对 ReentrantReadWriteLock 其读锁是共享锁，其写锁是独占锁。读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的

> 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。但是如果有一个线程想去写共享资源，就不应该再有其它线程可以对该资源进行读或写

**小总结：**

*  读 - 读能共存
 *  写 - 写不能共存

写操作：原子 + 独占，整个过程必须是一个完整的统一体，中间不许被分割，被打断

## 举例（未使用读写锁） ##

package concurrency.day0411;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    
    /** * @author Woo_home * @create by 2020/4/12 12:39 */
    
    class MyCache {  // 资源类
        private volatile Map<String,Object> map = new HashMap<>();
    
    	// 写入操作
        public void put(String key, Object value) { 
            System.out.println(Thread.currentThread().getName() + "\t 正在写入：" + key);
            try { 
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            map.put(key,value);
            System.out.println(Thread.currentThread().getName() + "\t 写入完成：" + key);
        }
    
    	// 读取操作
        public void get(String key) { 
            System.out.println(Thread.currentThread().getName() + "\t 正在读取：");
            try { 
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读取完成：" + result);
        }
    }
    
    public class ReadWriteLockDemo { 
        public static void main(String[] args) { 
            MyCache myCache = new MyCache();
    
    		// 5个线程写入数据
            for (int i = 0; i < 5; i++) { 
                final int tempInt = i;
                new Thread(() -> { 
                    myCache.put(tempInt+"",tempInt+"");
                },String.valueOf(i)).start();
            }
    
    		// 5个线程读取数据
            for (int i = 0; i < 5; i++) { 
                final int tempInt = i;
                new Thread(() -> { 
                    myCache.get(tempInt+"");
                },String.valueOf(i)).start();
            }
        }
    }

输出：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 1]  
可以发现打印乱七八糟的，一个线程还没写入完成另一个线程就跟着写入了

## 举例（使用读写锁） ##

package concurrency.day0411;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /** * @author Woo_home * @create by 2020/4/12 12:39 */
    
    class MyCache {  // 资源类
        private volatile Map<String,Object> map = new HashMap<>();
    
    	// 使用读写锁
        private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    
        public void put(String key, Object value) { 
        	// 写之前加锁
            readWriteLock.writeLock().lock();
            try { 
                System.out.println(Thread.currentThread().getName() + "\t 正在写入：" + key);
                try { 
                    TimeUnit.MILLISECONDS.sleep(300);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                map.put(key,value);
                System.out.println(Thread.currentThread().getName() + "\t 写入完成：" + key);
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
            	// 写完后解锁
                readWriteLock.writeLock().unlock();
            }
    
        }
    
        public void get(String key) { 
        	// 读之前加锁
            readWriteLock.readLock().lock();
            try { 
                System.out.println(Thread.currentThread().getName() + "\t 正在读取：");
                try { 
                    TimeUnit.MILLISECONDS.sleep(300);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                Object result = map.get(key);
                System.out.println(Thread.currentThread().getName() + "\t 读取完成：" + result);
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
            	// 读完后解锁
                readWriteLock.readLock().unlock();
            }
        }
    }
    
    public class ReadWriteLockDemo { 
        public static void main(String[] args) { 
            MyCache myCache = new MyCache();
    
            for (int i = 0; i < 5; i++) { 
                final int tempInt = i;
                new Thread(() -> { 
                    myCache.put(tempInt+"",tempInt+"");
                },String.valueOf(i)).start();
            }
    
            for (int i = 0; i < 5; i++) { 
                final int tempInt = i;
                new Thread(() -> { 
                    myCache.get(tempInt+"");
                },String.valueOf(i)).start();
            }
        }
    }

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

[2020041120174359.png]: /images/20221124/37c2f1a48ad541929431656d581c2014.png
[20200411202131268.png]: /images/20221124/39781e9e35cc44ba9613384bbfba5920.png
[2020041120225522.png]: /images/20221124/39823da7b3fe4ef88d2cf396d1f8ca39.png
[20200411202243377.png]: /images/20221124/870d73088efc463f9f58d28246977c0b.png
[20200411201043326.png]: /images/20221124/a903d709a0df44a5878a9facbcd21416.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70]: /images/20221124/36ae9de194cf49fb9da476fd09b79e28.png
[2020041212102040.png]: /images/20221124/287e92d91a7f4515bb548652c0f8a803.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 1]: /images/20221124/18b4bfa7cbc244b4bce10a149f2afa0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 2]: /images/20221124/03ea06dc5c844cb7adcda0a3edeef331.png