Java乐观锁%悲观锁

1.乐观锁

尝试去获得一把锁，无论获得还是无法获得立刻返回True/False 不会阻塞进程，使用此锁可在获取锁的过程中完成其它操作。如下例子演示了在线程1获得了锁之后，线程2使用trylock()可以初始化一些参数，缺点是这里比较消耗CPU资源，使用时建议添加延时并设置尝试次数来限制CPU的使用。

/**
* 乐观锁
*/
public class Lock {
    public static void main(String[] args) {
        ReentrantLock reentrantLock = new ReentrantLock();
		// 线程1
        new Thread(new Runnable() {
            @Override
            public void run() {
                reentrantLock.lock();
                System.out.println("获得锁1");
                try {
                    Thread.sleep(10*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                reentrantLock.unlock(); // 解锁
            }
        }).start();
		// 线程2
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (!reentrantLock.tryLock()){
                	// 在这里可以做一些事情
                    System.out.println("乐观锁: 生效，初始化参数成功");
                    try {
                        Thread.sleep(2*1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("获得锁2");
                reentrantLock.unlock();  // 解锁
            }
        }).start();
    }
}

锁生效：trylock初始化参数成功

2.悲观锁

同样是去获取一把锁，而此锁如果获取不到锁就会阻塞，直到获得这把锁，下面的例子演示了进程阻塞

/**
* 悲观锁
*/
public class Lock {
    public static void main(String[] args) {
        ReentrantLock reentrantLock = new ReentrantLock();
		// 线程1
        new Thread(new Runnable() {
            @Override
            public void run() {
                reentrantLock.lock();
                System.out.println("获得锁1");
                try {
                    Thread.sleep(10*1000); // 睡眠10秒模拟阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                reentrantLock.unlock(); // 解锁
            }
        }).start();
        // 线程2
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println("线程3运行中");
                    try {
                        Thread.sleep(2*1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
		// 线程3        
        new Thread(new Runnable() {
            @Override
            public void run() {
                //
                reentrantLock.lock();
                System.out.println("获得锁2");
                reentrantLock.unlock();  // 解锁
            }
        }).start();
    }
}

运行结果：从结果上看，线程3已经进入了阻塞状态，直达线程1释放了锁才开始工作，缺点：在等待过程中不能做其它事情，如果线程1阻塞则线程2也阻塞，优点：阻塞过程不消耗CPU资源

原文链接：https://blog.csdn.net/qq_40826249/article/details/121348869