详解Java多线程tryLock()方法使用

什么是tryLock()方法

tryLock方法是Java多线程中使用的一种同步锁机制。它尝试获取锁，如果锁可用则获取锁并返回true，如果锁不可用则直接返回false，而不会阻塞等待锁。

tryLock方法的定义为：

public boolean tryLock()

tryLock方法会试图去获取锁，如果锁已经被其他线程占用，则等待一段时间直到超时（timeout），如果在等待超时前锁被释放，则锁会被立即获取。

tryLock方法还有一个带参数的重载方法，请参考下面示例：

public boolean tryLock(long timeout, TimeUnit unit)

该方法会尝试获取锁，如果锁在 timeout 时间内没有被其他线程持有，则获取锁并返回 true。如果在 timeout 时间内锁一直未被释放，则返回 false。

使用tryLock()方法

在Java多线程编程中，要确保对共享数据的读写操作或是对共享资料的访问不会产生数据不一致等问题，这时就需要使用到同步机制来保证线程安全。

接下来我们举两个例子来说明 tryLock 方法的使用。

示例1

import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {

    private ReentrantLock lock = new ReentrantLock();

    public void method1() {
        if (lock.tryLock()) {
            try {
                System.out.println(Thread.currentThread().getName() + "获得了锁，执行method1方法");
                Thread.sleep(1000); // 模拟方法执行需要耗费一定时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 释放锁
                lock.unlock();
            }
        } else {
            System.out.println(Thread.currentThread().getName() + "未获得锁，执行method1方法失败");
        }
    }

    public static void main(String[] args) {
        LockDemo lockDemo = new LockDemo();

        // 启动线程1，先执行method1方法
        new Thread(lockDemo::method1, "thread1").start();

        // 等待1秒后启动线程2，再执行method1方法
        try {
            Thread.sleep(1000); // 确保线程1先获得锁
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(lockDemo::method1, "thread2").start();
    }
}

在上面的示例代码中，我们使用了一个 ReentrantLock 锁来保证线程安全。在 method1() 方法中我们尝试获取锁，如果获取锁成功则执行方法逻辑并释放锁，否则输出提示信息表示获取锁失败。

输出结果如下：

thread1获得了锁，执行method1方法
thread2未获得锁，执行method1方法失败

可以发现线程1先获取了锁并执行了 method1() 方法，而线程2则因为在等待超时时间内没有获取到锁则执行失败。

示例2

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {

    private ReentrantLock lock = new ReentrantLock();

    public void method2() {
        try {
            if (lock.tryLock(5, TimeUnit.SECONDS)) { // 尝试等待5秒去获取锁
                try {
                    System.out.println(Thread.currentThread().getName() + "获得了锁，执行method2方法");
                    Thread.sleep(1000); // 模拟方法执行需要耗费一定时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 释放锁
                    lock.unlock();
                }
            } else {
                System.out.println(Thread.currentThread().getName() + "未获得锁，执行method2方法失败");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        LockDemo lockDemo = new LockDemo();

        // 启动线程1，先执行method2方法
        new Thread(lockDemo::method2, "thread1").start();

        // 等待1秒后启动线程2，再执行method2方法
        try {
            Thread.sleep(1000); // 确保线程1先获得锁
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(lockDemo::method2, "thread2").start();
    }
}

在上面的示例代码中，我们同样使用了 ReentrantLock 锁来保证线程安全，在 method2() 方法中我们尝试等待5秒去获取锁，如果在5秒内获取到锁则执行方法逻辑并释放锁，否则输出提示信息表示获取锁失败。

输出结果如下：

thread1获得了锁，执行method2方法
thread2未获得锁，执行method2方法失败

可以发现线程1先获取了锁并执行了 method2() 方法，而线程2则因为等待超过超时时间未获取到锁则抛出异常并执行失败。

小结

tryLock 方法是Java多线程中使用的一种同步锁机制，它通过尝试获取锁并返回结果来避免线程的阻塞等待。通过示例代码我们可以看到 tryLock 方法的简单使用方法和效果。