Java进阶学习笔记（八）多线程编程（五）LOCK对象

最新推荐文章于 2024-04-22 22:29:02 发布

TUTsmile

最新推荐文章于 2024-04-22 22:29:02 发布

阅读量168

点赞数

分类专栏： Java学习文章标签： lock java 多线程并发编程

原文链接：https://how2j.cn/k/thread/thread-atomic-access/683.html

版权

Java学习专栏收录该内容

15 篇文章

订阅专栏

文章目录

LOCK对象

LOCK对象

1、使用Lock实现同步效果

示例
Lock是一个接口，为了使用一个Lock对象，需要用到new

Lock lock = new ReentrantLock();

与 synchronized (someObject) 类似的，lock()方法，表示当前线程占用lock对象，一旦占用，其他线程就不能占用了。

与 synchronized 不同的是，一旦synchronized 块结束，就会自动释放对someObject的占用。 lock却必须调用unlock方法进行手动释放，为了保证释放的执行，往往会把unlock() 放在finally中进行。

    public static void printfLog(String msg) {
        System.out.printf("%s %s %s %n", now() , Thread.currentThread().getName() , msg);
    }

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();

        Thread thread1 = new Thread() {
            @Override
            public void run() {
                try {
                    printfLog("线程启动");
                    printfLog("占有lock");
                    lock.lock();
//                    将近5s的业务处理
                    Thread.sleep(5000);
                    printfLog("业务结束，释放lock");
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        };
        thread1.setName("一号");
        thread1.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread thread2 = new Thread() {
            @Override
            public void run() {
                try {
                    printfLog("启动");
                    printfLog("试图占有lock");
                    lock.lock();

                    printfLog("占有lock");
                    printfLog("进行五秒业务操作");
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    printfLog("释放对象lock");
                    lock.unlock();
                }
                printfLog("线程结束");
            }
        };
        thread2.setName("二号线程");
        thread2.start();
    }

运行结果

17:21:52 一号 线程启动 
17:21:52 一号 占有lock 
17:21:54 二号线程 启动 
17:21:54 二号线程 试图占有lock 
17:21:57 一号 业务结束，释放lock 
17:21:57 二号线程 占有lock 
17:21:57 二号线程 进行五秒业务操作 
17:22:02 二号线程 释放对象lock 
17:22:02 二号线程 线程结束 

Process finished with exit code 0

2、tryLock

synchronized 是不占用到手不罢休的，会一直试图占用下去。
与 synchronized 的钻牛角尖不一样，Lock接口还提供了一个trylock方法。
trylock会在指定时间范围内试图占用，占成功了，就执行。如果时间到了，还占用不成功，扭头就走~

注意：因为使用trylock有可能成功，有可能失败，所以后面unlock释放锁的时候，需要判断是否占用成功了，如果没占用成功也unlock,就会抛出异常

    public static String now() {
        return new SimpleDateFormat("HH:mm:ss").format(new Date());
    }

    public static void log(String msg) {
        System.out.printf("%s %s %s %n", now() , Thread.currentThread().getName() , msg);
    }

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();

        Thread t1 = new Thread() {
            @Override
            public void run() {
                boolean locked = false;
                try {
                    log("线程启动");
                    log("试图占有对象：lock");

                    locked = lock.tryLock(1,TimeUnit.SECONDS);
                    if(locked){
                        log("占有对象：lock");
                        log("进行5秒的业务操作");
                        Thread.sleep(5000);
                    }
                    else{
                        log("经过1秒钟的努力，还没有占有对象，放弃占有");
                    }

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {

                    if(locked){
                        log("释放对象：lock");
                        lock.unlock();
                    }
                }
                log("线程结束");
            }
        };
        t1.setName("一号");
        t1.start();

        try {
            //先让t1飞2秒
            Thread.sleep(2000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        Thread t2 = new Thread() {
            @Override
            public void run() {
                boolean locked = false;
                try {
                    log("线程启动");
                    log("试图占有对象：lock");

                    locked = lock.tryLock(1,TimeUnit.SECONDS);
                    if(locked){
                        log("占有对象：lock");
                        log("进行5秒的业务操作");
                        Thread.sleep(5000);
                    }
                    else{
                        log("经过1秒钟的努力，还没有占有对象，放弃占有");
                    }

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {

                    if(locked){
                        log("释放对象：lock");
                        lock.unlock();
                    }
                }
                log("线程结束");
            }
        };
        t2.setName("二号线程");
        t2.start();
    }

执行结果

17:27:37 一号 线程启动 
17:27:37 一号 试图占有对象：lock 
17:27:37 一号 占有对象：lock 
17:27:37 一号 进行5秒的业务操作 
17:27:39 二号线程 线程启动 
17:27:39 二号线程 试图占有对象：lock 
17:27:40 二号线程 经过1秒钟的努力，还没有占有对象，放弃占有 
17:27:40 二号线程 线程结束 
17:27:42 一号 释放对象：lock 
17:27:42 一号 线程结束 

Process finished with exit code 0

3、线程交互

使用synchronized方式进行线程交互，用到的是同步对象的 wait, notify 和 notifyAll 方法

Lock也提供了类似的解决办法，首先通过lock对象得到一个Condition对象，然后分别调用这个Condition对象的：await（等待）, signal（发一个信号）, signalAll（发送信号给所有人）方法。

示例

    public static String now() {
        return new SimpleDateFormat("HH:mm:ss").format(new Date());
    }

    public static void log(String msg) {
        System.out.printf("%s %s %s %n", now() , Thread.currentThread().getName() , msg);
    }

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        Thread t1 = new Thread() {
            @Override
            public void run() {
                try {
                    log("线程启动");
                    log("试图占有对象：lock");

                    lock.lock();

                    log("占有对象：lock");
                    log("进行5秒的业务操作");
                    Thread.sleep(5000);
                    log("临时释放对象 lock， 并等待");
                    condition.await();
                    log("重新占有对象 lock，并进行5秒的业务操作");
                    Thread.sleep(5000);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    log("释放对象：lock");
                    lock.unlock();
                }
                log("线程结束");
            }
        };
        t1.setName("一号");
        t1.start();

        try {
            //先让t1飞2秒
            Thread.sleep(2000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        Thread t2 = new Thread() {
            @Override
            public void run() {
                try {
                    log("线程启动");
                    log("试图占有对象：lock");

                    lock.lock();

                    log("占有对象：lock");
                    log("进行5秒的业务操作");
                    Thread.sleep(5000);
                    log("唤醒等待中的线程");
                    condition.signal();

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    log("释放对象：lock");
                    lock.unlock();
                }
                log("线程结束");
            }
        };
        t2.setName("二号线程");
        t2.start();
    }

运行结果

19:23:39 一号 线程启动 
19:23:39 一号 试图占有对象：lock 
19:23:39 一号 占有对象：lock 
19:23:39 一号 进行5秒的业务操作 
19:23:41 二号线程 线程启动 
19:23:41 二号线程 试图占有对象：lock 
19:23:44 一号 临时释放对象 lock， 并等待 
19:23:44 二号线程 占有对象：lock 
19:23:44 二号线程 进行5秒的业务操作 
19:23:49 二号线程 唤醒等待中的线程 
19:23:49 二号线程 释放对象：lock 
19:23:49 二号线程 线程结束 
19:23:49 一号 重新占有对象 lock，并进行5秒的业务操作 
19:23:54 一号 释放对象：lock 
19:23:54 一号 线程结束 

Process finished with exit code 0

4、总结Lock和synchronized的区别

Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现，Lock是代码层面的实现。
Lock可以选择性的获取锁，如果一段时间获取不到，可以放弃。synchronized不行，会一根筋一直获取下去。借助Lock的这个特性，就能够规避死锁，synchronized必须通过谨慎和良好的设计，才能减少死锁的发生。
synchronized在发生异常和同步块结束的时候，会自动释放锁。而Lock必须手动释放，所以如果忘记了释放锁，一样会造成死锁。