Lock的lock()、lockInterruptibly()、tryLock()方法区别

迈不过友情╰ 2023-06-19 09:57 18阅读 0赞

#### lockInterruptibly() ####

中断锁，线程等待锁的过程中如果被中断，则会立刻进入该线程，响应中断异常（异常抛出的话就进入上层处理异常）  
如果没有被中断，则跟lock()方法一样

package day20191203;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /** * @Author: xiaoshijiu * @Date: 2019/12/5 * @Description: lockInterruptibly()，中断锁 * 线程等待锁的过程中如果被中断，则会立刻进入该线程，响应中断 */
    public class TestLockInterruptibly { 
    
        private Lock lock = new ReentrantLock();
    
        private void doSomething() { 
            try { 
                lock.lockInterruptibly();
                System.out.println(Thread.currentThread().getName() + "\t获得锁");
                System.out.println(Thread.currentThread().getName() + "\t正在DoSomething");
                // 睡眠5秒，能确保看得到效果
                Thread.sleep(5000L);
                System.out.println(Thread.currentThread().getName() + "\t释放锁");
            } catch (InterruptedException e) { 
                e.printStackTrace();
                System.out.println(Thread.currentThread().getName() + "\t中断了");
            } finally { 
                lock.unlock();
            }
        }
    
        public static void main(String[] args) { 
    
            TestLockInterruptibly testLockInterruptibly = new TestLockInterruptibly();
    
            Thread thread1 = new Thread(() -> { 
                System.out.println(Thread.currentThread().getName() + "\t进来了");
                testLockInterruptibly.doSomething();
            }, "AA");
    
            thread1.start();
    
            // main主线程睡眠一会，确保线程1在线程2之前执行
            try { 
                Thread.sleep(1000L);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            Thread thread2 = new Thread(() -> { 
                System.out.println(Thread.currentThread().getName() + "\t进来了");
                testLockInterruptibly.doSomething();
            }, "BB");
    
            thread2.start();
    
            // 1秒后，中断线程2
            try { 
                Thread.sleep(1000L);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            thread2.interrupt();
        }
    }

执行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70]  
AA线程1获取到锁之后，执行自身代码；BB线程2等待锁，但是此时main线程中断了线程2，因为是lockInterruptibly()等待锁，所以直接响应中断异常

#### lock() ####

线程在等待锁的过程中，不会响应中断（会一直等待获取锁），但是在中断点（sleep）会响应之前的中断

package day20191203;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /** * @Author: xiaoshijiu * @Date: 2019/12/5 * @Description: lock.lock() * lock，非中断锁，线程在等待锁的过程中，不会响应中断（会一直等待获取锁），但是在中断点会响应中断（sleep） */
    public class TestLock { 
        private Lock lock = new ReentrantLock();
    
        private void doSomething() { 
            try { 
                lock.lock();
                System.out.println(Thread.currentThread().getName() + "\t获得锁");
                System.out.println(Thread.currentThread().getName() + "\t正在DoSomething");
                // 睡眠5秒，能确保看得到效果
                Thread.sleep(5000L);
                System.out.println(Thread.currentThread().getName() + "\t释放锁");
            } catch (InterruptedException e) { 
                e.printStackTrace();
                System.out.println(Thread.currentThread().getName() + "\t中断了");
            } finally { 
                lock.unlock();
            }
        }
    
        /** * doSomething2方法，没有sleep，就一直不会响应中断 */
        private void doSomething2() { 
            try { 
                lock.lock();
                System.out.println(Thread.currentThread().getName() + "\t获得锁");
                System.out.println(Thread.currentThread().getName() + "\t正在DoSomething");
                System.out.println(Thread.currentThread().getName() + "\t释放锁");
            } catch (Exception e) { 
                e.printStackTrace();
                System.out.println(Thread.currentThread().getName() + "\t中断了");
            } finally { 
                lock.unlock();
            }
        }
    
        public static void main(String[] args) { 
    
            TestLock testLock = new TestLock();
    
            Thread thread1 = new Thread(() -> { 
                System.out.println(Thread.currentThread().getName() + "\t进来了");
                testLock.doSomething();
            }, "AA");
    
            thread1.start();
    
            // main主线程睡眠一会，确保线程1在线程2之前执行
            try { 
                Thread.sleep(1000L);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            Thread thread2 = new Thread(() -> { 
                System.out.println(Thread.currentThread().getName() + "\t进来了");
                testLock.doSomething2();
            }, "BB");
    
            thread2.start();
    
            // 1秒后，中断线程2
            try { 
                Thread.sleep(1000L);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            thread2.interrupt();
        }
    }

执行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70 1]  
跟上面的区别就是：虽然main线程也中断了BB线程2，但是由于是lock()方法等待锁，所以并不会响应中断，而是一直等待获取锁

如果在BB线程中调用sleep方法（中断点），就会响应之前的中断，处理InterruptedException异常，感兴趣的可以自己试一试

#### tryLock() ####

是一种比较潇洒的获取锁的方式  
有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false;  
这个方法无论如何都会立即返回，即使拿不到锁也不会一直在那等待。

还有一个重载方法  
boolean tryLock(long time, TimeUnit unit)  
表示在一定时间内重试获取锁，获取不到再返回

package day20191203;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /** * @Author: xiaoshijiu * @Date: 2019/12/5 * @Description: lock.tryLock()，是一种比较潇洒的获取锁的方式 * 有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false， * 这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。 */
    public class TestTryLock { 
        public static void main(String[] args) { 
            Lock lock = new ReentrantLock();
            new Thread(() -> { 
                String tName = Thread.currentThread().getName();
                if (lock.tryLock()) { 
                    System.out.println(tName + "\t获取到锁！");
                } else { 
                    System.out.println(tName + "\t没获取到锁！");
                    // 获取不到锁，直接return掉，避免继续执行下面，遇到unlock方法会抛出异常
                    return;
                }
                try { 
                    for (int i = 0; i < 5; i++) { 
                        System.out.println(tName + ":" + i);
                    }
                    Thread.sleep(1000);
                } catch (Exception e) { 
                    System.out.println(tName + "\t出错了！！！");
                } finally { 
                    System.out.println(tName + "\t释放锁！！");
                    lock.unlock();
                }
    
            }, "AA").start();
    
            new Thread(() -> { 
                String tName = Thread.currentThread().getName();
                if (lock.tryLock()) { 
                    System.out.println(tName + "\t获取到锁！");
                } else { 
                    System.out.println(tName + "\t获取不到锁！");
                    // 获取不到锁，直接return掉，避免继续执行下面，遇到unlock方法会抛出异常
                    return;
                }
                try { 
                    for (int i = 0; i < 5; i++) { 
                        System.out.println(tName + ":" + i);
                    }
    
                } catch (Exception e) { 
                    System.out.println(tName + "\t出错了！！！");
                } finally { 
                    System.out.println(tName + "\t释放锁！！");
                    lock.unlock();
                }
    
            }, "BB").start();
        }
    }

执行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70 2]  
需要注意的一点是：

使用tryLock()时最好使用if判断，false时直接return；  
因为没有获取到锁也会执行下面的代码，也就会发生执行到unlock时报错的情况

比如上面的代码块  
BB线程2，else里面没有写return  
那执行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70 3]  
可见，BB线程2也会继续往下执行，发生的异常是unlock()那里（没有加锁，何来解锁）

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191205203311356.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/20191205203155119.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 2]: https://img-blog.csdnimg.cn/20191205204134568.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 3]: https://img-blog.csdnimg.cn/20191205204705664.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz,size_16,color_FFFFFF,t_70