【7、lock、tryLock、lockInterruptibly有什么区别？以及使用案例】

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();
        }
    }
}