多线程 - lock、tryLock、lockInterruptibly有什么区别？以及使用案例

秒速五厘米 2023-10-04 21:48 3阅读 0赞

## lock、tryLock 和 lockInterruptibly 是Java中用于控制并发访问的三种不同方式。它们之间的区别在以下方面： ##

### lock() 方法 ###

lock() 方法是一种阻塞的方式，即如果获取不到锁，当前线程会被阻塞，直到锁可用为止。当一个线程获得锁后，其他线程尝试获得锁将被阻塞，直到持有锁的线程释放锁。

### tryLock() 方法 ###

tryLock() 方法是一种非阻塞的方式，它会尝试获取锁，如果锁不可用，则直接返回 false。因此，tryLock() 方法不会使线程阻塞。

### lockInterruptibly() 方法 ###

lockInterruptibly() 方法是一种可以响应中断的阻塞方式，即如果获取不到锁，当前线程会被阻塞，直到锁可用为止。与 lock() 方法不同的是，lockInterruptibly() 方法可以在等待获取锁的过程中响应中断，即如果其他线程中断了等待线程，则该方法会抛出 InterruptedException 异常。

因此，这三种方法的选择取决于你的具体需求。如果你希望线程等待直到获取到锁，可以使用 lock() 方法；如果你希望线程尝试获取锁并立即返回结果，则可以使用 tryLock() 方法；如果你希望在等待获取锁的过程中响应中断，则可以使用 lockInterruptibly() 方法。

### lock() 方法示例： ###

在这个例子中，使用 ReentrantLock 创建了一个可重入锁，并使用 lock() 方法来获取锁并更新计数器。

package com.lfsun.main.point.demomulthread.lock.lockexample;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class LockExample {
        
        private final Lock lock = new ReentrantLock();
        private int count = 0;
    
        public void increment() {
        
            lock.lock();
            try {
        
                count++;
            } finally {
        
                lock.unlock();
            }
        }
    
        public int getCount() {
        
            lock.lock();
            try {
        
                return count;
            } finally {
        
                lock.unlock();
            }
        }
    }

### tryLock() 方法示例 ###

在这个例子中，使用 tryLock() 方法尝试获取锁，如果锁不可用，则直接返回 false。如果锁可用，则更新计数器并返回 true。

package com.lfsun.main.point.demomulthread.lock.lockexample;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class TryLockExample {
        
        private final Lock lock = new ReentrantLock();
        private int count = 0;
    
        public boolean increment() {
        
            if (lock.tryLock()) {
        
                try {
        
                    count++;
                    return true;
                } finally {
        
                    lock.unlock();
                }
            } else {
        
                return false;
            }
        }
    
        public int getCount() {
        
            lock.lock();
            try {
        
                return count;
            } finally {
        
                lock.unlock();
            }
        }
    }

### lockInterruptibly() 方法示例 ###

在这个例子中，我们使用 lockInterruptibly() 方法获取锁并更新计数器。如果其他线程中断了等待线程，则该方法会抛出 InterruptedException 异常。

package com.lfsun.main.point.demomulthread.lock.lockexample;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class LockInterruptiblyExample {
        
        private final Lock lock = new ReentrantLock();
        private int count = 0;
    
        public void increment() throws InterruptedException {
        
            lock.lockInterruptibly();
            try {
        
                count++;
            } finally {
        
                lock.unlock();
            }
        }
    
        public int getCount() {
        
            lock.lock();
            try {
        
                return count;
            } finally {
        
                lock.unlock();
            }
        }
    }