Java递归锁（可重入锁）

冷不防 2023-06-16 08:11 16阅读 0赞

Java里面递归锁又叫可重入锁

1.  定义
    
    同一个线程在内层方法获取到锁之后，在进入内层方法会自动获取锁
    
    也就是说
    
    **线程可以进入任何一个他已经拥有的锁所同步着的代码块**
2.  代码验证
    
    lock 和 synchronized 都是递归锁
    
    2.1 synchronized 代码验证
    
        /** * @Author: xiaoshijiu * @Date: 2019/11/25 * @Description: synchronized递归锁代码验证 */
        public class SynchTest { 
        
            public synchronized void test() { 
                System.out.println(Thread.currentThread().getName());
                // 调用test2方法，test2方法也是经过synchronized加锁的方法
                test2();
            }
        
            public synchronized void test2() { 
                System.out.println(Thread.currentThread().getName());
            }
        
            public static void main(String[] args) { 
                SynchTest synchTest = new SynchTest();
                for (int i = 0; i < 5; i++) { 
                    new Thread(() -> { 
                        synchTest.test();
                    }, "T" + i).start();
                }
            }
        
            /** * 运行结果表明：同一个线程获取到外层方法的锁后，会自动获取到内层方法的锁 * 即递归锁 */
        }
    
    运行结果  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70]  
    运行结果表明：内层方法虽然加锁了，但是并不需要再竞争锁资源，即  
    同一个线程获取到外层方法的锁后，会自动获取到内层方法的锁，即递归锁
    
    2.2 lock 代码验证
    
        import java.util.concurrent.locks.Lock;
        import java.util.concurrent.locks.ReentrantLock;
        
        /** * @Author: xiaoshijiu * @Date: 2019/11/25 * @Description: Lock是递归锁代码验证 */
        public class LockTest { 
        
            Lock lock = new ReentrantLock();
        
            public void test() { 
                lock.lock();
                try { 
                    System.out.println(Thread.currentThread().getName());
                    test2();
                } catch (Exception e) { 
                    e.printStackTrace();
                } finally { 
                    lock.unlock();
                }
            }
        
            public void test2() { 
                lock.lock();
                try { 
                    System.out.println(Thread.currentThread().getName());
                } catch (Exception e) { 
                    e.printStackTrace();
                } finally { 
                    lock.unlock();
                }
            }
        
            public static void main(String[] args) { 
                LockTest lockTest = new LockTest();
                for (int i = 0; i < 5; i++) { 
                    new Thread(() -> { 
                        lockTest.test();
                    }, "T" + i).start();
                }
            }
        
            /** * 运行结果表明：同一个线程获取到外层方法的锁后，会自动获取到内层方法的锁 * 即递归锁 */
        }
    
    运行结果：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70 1]  
    运行结果表明：内层方法虽然加锁了，但是并不需要再竞争锁资源，即  
    同一个线程获取到外层方法的锁后，会自动获取到内层方法的锁，即递归锁

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2019112515423717.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191125154627625.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz,size_16,color_FFFFFF,t_70