Java——多线程高并发系列之Lock、ReentrantLock-阿里云开发者社区

文章目录：

写在前面

在 JDK5 中增加了 Lock 锁接口，有 ReentrantLock 实现类，ReentrantLock 锁称为可重入锁，它功能比 synchronized 多。

一般来说，我们称 synchronized 为内部锁，称 Lock 为显示锁。

说说synchronized和Lock的区别？

· synchronized是关键字，Lock是接口。

· synchronized无法获取锁的状态，Lock可以。

· synchronized会自动释放锁，Lock需要手动。

· synchronized没有Lock锁灵活（Lock锁可以自己定制）。

Demo1（先演示一下锁的可重入性）

package com.szh.lock;
/**
 * 演示锁的可重入性
 */
public class Test01 {
    public synchronized void metthod1() {
        System.out.println("同步方法1");
        //线程执行 metthod1() 方法,默认 this 作为锁对象,
        //在 metthod1() 方法中调用了 method2() 方法,注意当前线程还是持有 this 锁对象的
        //method2() 同步方法默认的锁对象也是 this 对象, 要执行 method2() 必须先获得 this 锁对象,
        //当前 this 对象被当前线程持有,可以 再次获得 this 对象, 这就是锁的可重入性.
        //假设锁不可重入的话,可能会造成死锁
        method2();
    }
    public synchronized void method2() {
        System.out.println("同步方法2");
        method3();
    }
    public synchronized void method3() {
        System.out.println("同步方法3");
    }
    public static void main(String[] args) {
        Test01 obj=new Test01();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.metthod1();
            }
        }).start();
    }
}

Demo2（ReentrantLock的基本使用）

首先呢，Lock是JDK5中新增的锁接口，它的实现类中有一个常用的就是ReentrantLock，在这其中，先介绍一下 lock()、unlock() 方法，第一个是先获得锁，第二个是释放锁，而在这两个方法之间的代码就可以看作同步代码块。就像之前的synchronized。

package com.szh.lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * ReentrantLock 的基本使用
 */
public class Test02 {
    //定义一个显示锁
    static Lock lock=new ReentrantLock();
    public static void method() {
        //先获得锁
        lock.lock();
        //for循环此时就是同步代码块
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + " ---> " + i);
        }
        //释放锁
        lock.unlock();
    }
    public static void main(String[] args) {
        Runnable r=new Runnable() {
            @Override
            public void run() {
                method();
            }
        };
        //启动三个线程
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }
}

可以看到，这里Thread-0线程先执行，经过lock.lock()获得了锁对象之后，执行for循环（此处相当于同步代码块），而在这个时候，Thread-1和Thread-2是无法进来执行for循环的，因为当前的锁对象是被Thread-0占有的，如果后两个子线程想要进来执行了话，必须等到Thread-0通过lock.unlock()方法释放锁对象之后，才可以执行。

Demo3（使用Lock锁同步不同方法中的代码块）

package com.szh.lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 使用 Lock 锁同步不同方法中的同步代码块
 */
public class Test03 {
    //定义锁对象
    static Lock lock=new ReentrantLock();
    public static void method1() {
        //经常在 try 代码块中获得 Lock 锁, 在 finally 子句中释放锁
        try {
            lock.lock(); //获得锁
            System.out.println(Thread.currentThread().getName() + " ---method1--- " + System.currentTimeMillis());
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " ---method1--- " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock(); //释放锁
        }
    }
    public static void method2() {
        //经常在 try 代码块中获得 Lock 锁, 在 finally 子句中释放锁
        try {
            lock.lock(); //获得锁
            System.out.println(Thread.currentThread().getName() + " ---method2--- " + System.currentTimeMillis());
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " ---method2--- " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock(); //释放锁
        }
    }
    public static void main(String[] args) {
        Runnable r1=new Runnable() {
            @Override
            public void run() {
                method1();
            }
        };
        Runnable r2=new Runnable() {
            @Override
            public void run() {
                method2();
            }
        };
        new Thread(r1).start();
        new Thread(r1).start();
        new Thread(r2).start();
        new Thread(r2).start();
    }
}

这里的执行结果：首先创建了4个子线程，Thread-0先抢到CPU执行权，进来获得lock锁对象，中间有一个sleep方法，这个的意思是让当前执行它的线程进入睡眠状态，但是当前线程不会释放它占有的锁，所以其他三个子线程是进不来的，因为当前lock锁对象被Thread-0占有了，在Thread-0执行完毕后。其他三个子线程都是同样的道理，只是说每次运行的结果可能会不相同，是因为线程的执行是抢着执行的。

Demo4（ReentrantLock锁的可重入性）

package com.szh.lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * ReentrantLock 锁的可重入性
 */
public class Test04 {
    static class SubThread extends Thread {
        //定义锁对象
        private static Lock lock=new ReentrantLock();
        //定义变量
        private static int num=0;
        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                try {
                    //可重入锁指可以反复获得该锁
                    lock.lock();
                    lock.lock();
                    num++;
                }finally {
                    lock.unlock();
                    lock.unlock();
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        SubThread t1=new SubThread();
        SubThread t2=new SubThread();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(SubThread.num);
    }
}

这个代码案例的意思：创建两个子线程，第一个子线程抢到了CPU执行权，开始执行，第一个lock.lock()获得了锁对象，之后还可以再次lock.lock()第二次获得该锁对象，这是完全可以的，也就是说Lock接口的实现类ReentrantLock是支持锁的可重入性的。但是释放锁的时候，你线程获得了几个锁对象，这里就需要释放几次锁对象。

如果说第一个子线程连续执行两次lock.lock()获得了两次锁对象，但是只执行一次lock.unlock()了话，就会出现一种结果：程序卡在这里了，因为第一个子线程申请了两个当前锁对象，只释放了一次当前锁对象，那么还有一个锁对象被它占有着，这就导致第二个子线程没法执行了，因为第一个子线程没有释放完锁对象，那么第二个子线程获得不到当前lock锁对象，就没法继续执行下去了，所以，程序卡在这里了。

Demo5（ReentrantLock的lockInterruptibly()方法）

package com.szh.lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * lockInterruptibly()方法
 *  如果当前线程未被中断则获得锁,
 *  如果当前线程被中断则出现异常.
 */
public class Test05 {
    static class Service {
        private Lock lock=new ReentrantLock(); //定义锁对象
        public void serviceMethod() {
            try {
                //lock.lock();  获得锁, 即使调用了线程的 interrupt() 方法, 也没有真正的中断线程
                //如果线程被中断了, 不会获得锁, 会产生异常
                lock.lockInterruptibly();
                System.out.println(Thread.currentThread().getName() + " --- begin lock");
                //执行一段耗时的操作
                for (int i = 0; i < Integer.MAX_VALUE; i++) {
                    new StringBuilder();
                }
                System.out.println(Thread.currentThread().getName() + " --- end lock");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + " === 释放锁");
                lock.unlock(); //释放锁
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Service s=new Service();
        Runnable r=new Runnable() {
            @Override
            public void run() {
                s.serviceMethod();
            }
        };
        Thread t1=new Thread(r);
        t1.start();
        Thread.sleep(50);
        Thread t2=new Thread(r);
        t2.start();
        Thread.sleep(50);
        t2.interrupt(); //中断 t2 线程
    }
}

lockInterruptibly()方法的作用：如果当前线程未被中断则获得锁，如果当前线程被中断则出现异常。

当你使用lock()来获得锁的时候，即使你让一个线程执行interrupt方法中断它也没有用。如果想让线程能够被中断了话，需要使用 lockInterruptibly() 方法。

上述代码的执行过程：创建了两个子线程，第一个子线程lock.lockInterruptibly()获得了锁对象，去执行同步代码块（for循环）了，因为start方法只要一给当前线程开辟出栈空间，那么它就结束了，开辟成功的线程就去执行自己的run方法了，而程序代码就可以正常向下执行了。所以这个时候第二个子线程也start了，它也会去执行run方法对应的要求，上来就是获得锁对象，而此时锁对象暂时被第一个子线程占有，而第一个子线程还在for循环那里呢（这个for循环很耗时的），这个时候main主线程中，已经走到了最后一行，中断第二个子线程，根据lock.lockInterruptibly()方法，如果执行它的线程被中断，则直接出现异常，所以第二个子线程会走catch子句，最后执行finally释放锁（当然了，它压根也就没获得锁，这里打印这句话是为了更好的理解），最后第一个子线程是可以顺利执行完、释放锁的。

Demo6（lockInterruptibly()方法可以避免死锁）

package com.szh.lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 通过 ReentrantLock 锁的 lockInterruptibly() 方法避免死锁的产生
 */
public class Test06 {
    static class MyLock implements Runnable {
        //创建两个ReentrantLock等锁对象
        private static ReentrantLock lock1=new ReentrantLock();
        private static ReentrantLock lock2=new ReentrantLock();
        int lockNum; //定义整数变量,决定使用哪个锁,偶数用lock1,奇数用lock2
        public MyLock(int lockNum) {
            this.lockNum=lockNum;
        }
        @Override
        public void run() {
            try {
                if (lockNum % 2 == 1) { //奇数, 先锁 1, 再锁 2
                    lock1.lockInterruptibly();
                    System.out.println(Thread.currentThread().getName() + "获得锁1，还需要获得锁2");
                    Thread.sleep(1000);
                    lock2.lockInterruptibly();
                    System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2");
                }else { //偶数, 先锁 2, 再锁 1
                    lock2.lockInterruptibly();
                    System.out.println(Thread.currentThread().getName() + "获得了锁2，还需要获得锁1");
                    Thread.sleep(1000);
                    lock1.lockInterruptibly();
                    System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2");
                }
            }catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                if (lock1.isHeldByCurrentThread()) { //判断当前线程是否持有该锁
                    lock1.unlock();
                }
                if (lock2.isHeldByCurrentThread()) {
                    lock2.unlock();
                }
                System.out.println(Thread.currentThread().getName() + "线程退出");
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        MyLock myLock1=new MyLock(11);
        MyLock myLock2=new MyLock(22);
        Thread t1=new Thread(myLock1);
        Thread t2=new Thread(myLock2);
        t1.start();
        t2.start();
        //在 main 线程, 等待 3000 ms, 如果还有线程没有结束就中断该线程
        Thread.sleep(1000 * 3);
        //可以中断任何一个线程来解决死锁, t2 线程会放弃对锁 1 的申请, 同时释放锁 2, t1 线程会完成它的任务
        if (t2.isAlive()) {
            t2.interrupt();
        }
    }
}

首先创建两个子线程，同时创建两个锁对象，这两个子线程一人一个锁，分别执行自己的start方法，main主线程此时睡眠3秒。

第一个子线程执行run方法，首先获得锁1，然后sleep了1秒，让出CPU执行权，但不会释放锁；此时第二个子线程执行run方法，首先获得锁2，然后sleep了1秒；第一个子线程醒了，它还想获得锁2，锁2已被第二个子线程占有，无法获得；第二个子线程醒了，它还想获得锁1，锁1已被第一个子线程占有，无法获得；这个时候差不多main主线程也该醒了，它会判断当前的t2子线程是否还活着，如果活着，则中断t2子线程；根据lockInterruptibly()方法，如果被中断，则产生异常，所以此时第二个子线程会走catch子句，最后finally子句判断第二个子线程是否占有锁1、锁2，有就释放，最后第二个子线程执行完毕退出；最后剩了第一个子线程，因为锁2已经被第二个子线程释放了，所以它此时可以获得锁2了，那就顺利执行呗，到最后的finally子句，正常释放锁对象就可以了。

Demo7（ReentrantLock的tryLock(long time, TimeUnit unit)方法）

package com.szh.lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/**
 * tryLock(long time, TimeUnit unit) 的作用在给定等待时长内,
 * 锁没有被另外的线程持有, 并且当前线程也没有被中断, 则获得该锁.
 * 通过该方法可以实现锁对象的限时等待.
 */
public class Test07 {
    static class TimeLock implements Runnable {
        private static ReentrantLock lock=new ReentrantLock(); //定义锁对象
        @Override
        public void run() {
            try {
                //假设 t1 线程先持有锁, 完成任务需要 4 秒钟,
                //这个时候 t2 线程尝试获得锁, t2 线程在 3 秒内还没有获得锁的话, 那么它就不再等了，直接放弃
                if (lock.tryLock(3, TimeUnit.SECONDS)) {
                    System.out.println(Thread.currentThread().getName() + "获得锁，执行耗时任务");
                    Thread.sleep(1000 * 4);
                    /*
                        假设 t1 线程先持有锁, 完成任务需要 2 秒钟
                        这个时候t2 线程尝试获得锁, t2 线程会一直尝试
                        在它约定尝试的 3 秒内可以获得锁对象
                     */
                    //Thread.sleep(1000 * 2);
                }else {
                    System.out.println(Thread.currentThread().getName() + "没有获得锁");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                if (lock.isHeldByCurrentThread()) {
                    lock.unlock();
                }
            }
        }
    }
    public static void main(String[] args) {
        TimeLock timeLock=new TimeLock();
        Thread t1=new Thread(timeLock);
        Thread t2=new Thread(timeLock);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
}

ReentrantLock类中的tryLock(long time, TimeUnit unit)方法有两个参数，第一个参数是指定时间，第二个参数是时间的级别（它是一个枚举）。代码中的意思是时间是3、级别是SECONDS秒，所以就是3秒。

这里创建两个子线程，设置了它们各自的名称，之后分别start启动，当t1线程走到 lock.tryLock(3, TimeUnit.SECONDS) 时，会判断在3秒之内，如果这个锁没有被其他线程持有，而且t1线程也没有被中断，则获得该锁。那显然，此时lock锁对象无人持有，所以t1线程获得该锁，之后它睡眠了4秒；这个时候t2线程来了，它走到lock.tryLock(3, TimeUnit.SECONDS) 时，也会像t1线程那样去判断3秒之内，如果这个锁没有被其他线程持有，而且t2线程也没有被中断，则获得该锁；显然该锁对象已经被t1线程持有了，而且t1线程还睡眠了4秒，也就是说t2线程等待3秒之后，t1线程还没有释放该锁对象，所以t2线程是获取不到这个锁对象的，所以t2线程就不会再等了，直接放弃，走else。

Demo8（ReentrantLock的tryLock()方法）

package com.szh.lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * tryLock() 当锁对象没有被其他线程持有的情况下, 才会获得该锁定
 */
public class Test08 {
    static class Service {
        private ReentrantLock lock=new ReentrantLock();
        public void serviceMethod() {
            try {
                if (lock.tryLock()) {
                    System.out.println(Thread.currentThread().getName() + "获得锁定");
                    Thread.sleep(1000 * 3); //模拟执行任务的时长
                }else {
                    System.out.println(Thread.currentThread().getName() + "没有获得锁定");
                }
            }catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                if (lock.isHeldByCurrentThread()) {
                    lock.unlock();
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Service service=new Service();
        Runnable r=new Runnable() {
            @Override
            public void run() {
                service.serviceMethod();
            }
        };
        Thread t1=new Thread(r);
        t1.start();
        Thread.sleep(100);
        Thread t2=new Thread(r);
        t2.start();
    }
}

ReentrantLock类中的tryLock()方法，是对上面那个案例的一个方法重载，这个方法中没有参数。意思是说：当前线程申请该锁对象，如果该锁对象没有被其他线程持有，则获得该锁，同时返回true；否则返回false，不会进行等待。这个执行结果我就不再讲解了，很好理解的。

Demo9（tryLock()方法可以避免死锁）

package com.szh.lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 使用 tryLock() 可以避免死锁
 */
public class Test09 {
    static class MyLock implements Runnable {
        private static ReentrantLock lock1=new ReentrantLock();
        private static ReentrantLock lock2=new ReentrantLock();
        private int lockNum;
        public MyLock(int lockNum) {
            this.lockNum=lockNum;
        }
        @Override
        public void run() {
            if (lockNum % 2 == 0) { //偶数先锁 1, 再锁 2
                while (true) {
                    try {
                        if (lock1.tryLock()) {
                            System.out.println(Thread.currentThread().getName() + "获得了锁1，还想获得锁2");
                            Thread.sleep(50);
                            try {
                                if (lock2.tryLock()) {
                                    System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2，完成任务了");
                                    return;
                                }
                            } finally {
                                if (lock2.isHeldByCurrentThread()) {
                                    lock2.unlock();
                                }
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        if (lock1.isHeldByCurrentThread()) {
                            lock1.unlock();
                        }
                    }
                }
            }else { //奇数就先锁 2, 再锁 1
                while (true) {
                    try {
                        if (lock2.tryLock()) {
                            System.out.println(Thread.currentThread().getName() + "获得了锁2，还想获得锁1");
                            Thread.sleep(50);
                            try {
                                if (lock1.tryLock()) {
                                    System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2，完成任务了");
                                    return;
                                }
                            } finally {
                                if (lock1.isHeldByCurrentThread()) {
                                    lock1.unlock();
                                }
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        if (lock2.isHeldByCurrentThread()) {
                            lock2.unlock();
                        }
                    }
                }
            }
        }
    }
    public static void main(String[] args) {
        MyLock lock1=new MyLock(11);
        MyLock lock2=new MyLock(22);
        Thread t1=new Thread(lock1);
        Thread t2=new Thread(lock2);
        t1.start();
        t2.start();
        //运行后, 使用 tryLock() 尝试获得锁, 不会傻傻的等待, 通过循环不停的再次尝试, 如果等待的时间足够长, 线程总是会获得想要的资源
    }
}

Java——多线程高并发系列之Lock、ReentrantLock

文章目录：

写在前面

Demo1（先演示一下锁的可重入性）

Demo2（ReentrantLock的基本使用）

Demo3（使用Lock锁同步不同方法中的代码块）

Demo4（ReentrantLock锁的可重入性）

Demo5（ReentrantLock的lockInterruptibly()方法）

Demo6（lockInterruptibly()方法可以避免死锁）

Demo7（ReentrantLock的tryLock(long time, TimeUnit unit)方法）

Demo8（ReentrantLock的tryLock()方法）

Demo9（tryLock()方法可以避免死锁）

热门文章

最新文章

相关课程

相关电子书

相关实验场景