目录

juc下的常用子类

1. 对象锁juc.lock

2. synchronized和ReentrantLock的区别

juc下的常用子类

1. 对象锁juc.lock

对象锁juc.lock——JDK1.0就有的，需要JVM借助操作系统提供的mutex系统语句实现。

JDK1.5之后，Java语言自己实现的互斥锁实现，不需要借助操作系统的monitor机制。
在Java中除了synchronized关键字可以实现对象锁之外，java.util.concurrent中的Lock接口也可以实现对象锁。

使用Lock接口需要显示的进行加锁和解锁操作

与synchronized不同的是，有一个tryLock方法

加锁，获取锁失败的线程进入阻塞态，等待一段时间，时间过了若还未获取到锁恢复执行，放弃加锁，执行其他代码

解锁操作

代码演示

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

public class LockTest {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            lock.lock(); // 代码从这里开始加锁，直到碰到unlock解锁
            // 互斥代码块
            try {
                System.out.println(Thread.currentThread().getName() + "获取到锁，其他线程等待");
                Thread.sleep(8000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                // 只有获取锁成功的线程才需要执行unlock方法
                lock.unlock();
            }
            System.out.println(Thread.currentThread().getName() + "释放锁");
        }, "1号");
        t1.start();
        Thread t2 = new Thread(() -> {
            boolean isLock = false;
            try {
                isLock = lock.tryLock(3000, TimeUnit.MICROSECONDS);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                if (isLock) {
                    // 只有获取锁成功的线程才需要执行unlock方法
                    lock.unlock();
                }
            }
            System.out.println("只等3秒");
        }, "2号");
        t2.start();
    }
}

2. synchronized和ReentrantLock的区别

1. synchronized是Java的关键字，由JVM实现，需要依赖操作系统提供的线程互斥原语(mutex)；

Lock标准库的类和接口，其中一个最常用的子类(ReentrantLock，可重入锁)，由Java本身实现的，不需要依赖操作系统。

2. synchronized隐式的加锁和解锁，lock需要显示进行加锁和解锁。

3. synchronized在获取锁失败的线程时，死等；

lock可以使用tryLock等待一段时间之后自动放弃加锁，线程恢复执行。

4. synchronized是非公平锁；

ReentrantLock默认是非公平锁，可以在构造方法中传入true开启公平锁。

5. synchronized不支持读写锁，Lock子类ReentrantReadWriteLock支持读写锁。

一般场景synchronized足够用了，需要用超时等待锁，公平锁，读写锁再考虑使用juc.lock。