Java并发教程–锁定：显式锁定

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量115 收藏
点赞数
文章标签： 多线程 java 并发编程 python android

1.简介

在许多情况下，使用隐式锁定就足够了。 有时，我们将需要更复杂的功能。 在这种情况下， java.util.concurrent.locks包为我们提供了锁定对象。 当涉及到内存同步时，这些锁的内部机制与隐式锁相同。 区别在于显式锁提供了其他功能。

与隐式同步相比，主要优点或改进是：

  • 通过读取或写入来分离锁。
  • 一些锁允许并发访问共享资源（ ReadWriteLock ）。
  • 获取锁的不同方式：
    • 阻塞：lock（）

2.锁对象的分类

锁定对象实现以下两个接口之一：

  • Lock ：定义锁对象必须实现的基本功能。 基本上，这意味着获取和释放锁。 与隐式锁相反，此锁允许以非阻塞或可中断的方式（除阻塞方式外）获取锁。 主要实现：
    • 重入锁
  • ReadWriteLock ：它保留一对锁，一个锁用于只读操作，另一个锁用于写操作。 读锁可以由不同的读取器线程同时获取（只要写锁尚未获取资源），而写锁是互斥的。 这样，只要没有写操作，我们就可以让多个线程同时读取资源。 主要实现：
    • 重入ReadWriteLock

下面的类图显示了不同锁类之间的关系：

显式锁定

3.重入锁

此锁的工作方式与同步块相同。 只要一个线程尚未被另一个线程获取，它就会获取该锁，并且直到调用unlock之前，它才会释放该锁。 如果另一个线程已经获取了该锁，则尝试获取该锁的线程将被阻塞，直到另一个线程释放它为止。

我们将从一个没有锁的简单示例开始，然后我们将添加一个可重入锁以查看其工作方式。 

public class NoLocking {
    public static void main(String[] args) {
        Worker worker = new Worker();
        
        Thread t1 = new Thread(worker, "Thread-1");
        Thread t2 = new Thread(worker, "Thread-2");
        t1.start();
        t2.start();
    }
    
    private static class Worker implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " - 1");
            System.out.println(Thread.currentThread().getName() + " - 2");
            System.out.println(Thread.currentThread().getName() + " - 3");
        }
    }
}

由于上面的代码未同步，因此线程将被交错。 让我们看一下输出： 

Thread-2 - 1
Thread-1 - 1
Thread-1 - 2
Thread-1 - 3
Thread-2 - 2
Thread-2 - 3

现在，我们将添加一个可重入锁，以序列化对run方法的访问： 

public class ReentrantLockExample {
    public static void main(String[] args) {
        Worker worker = new Worker();
        
        Thread t1 = new Thread(worker, "Thread-1");
        Thread t2 = new Thread(worker, "Thread-2");
        t1.start();
        t2.start();
    }
    
    private static class Worker implements Runnable {
        private final ReentrantLock lock = new ReentrantLock();
        
        @Override
        public void run() {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + " - 1");
                System.out.println(Thread.currentThread().getName() + " - 2");
                System.out.println(Thread.currentThread().getName() + " - 3");
            } finally {
                lock.unlock();
            }
        }
    }
}

上面的代码将安全地执行，而不会交错线程。 您可能意识到我们可以使用同步块，并且效果是相同的。 现在出现的问题是可重入锁提供给我们什么好处？

下面介绍了使用这种类型的锁的主要优点：

  • 通过实现Lock接口提供了获取锁的其他方式：
    • lockInterruptible ：如果另一个线程拥有锁，则当前线程将尝试获取解除锁定并被阻塞，例如使用lock（）方法。
  • ReentrantLock类提供的其他方法，主要用于监视或测试。 例如， getHoldCount或isHeldByCurrentThread方法。

让我们看一个使用tryLock的示例，然后再继续下一个锁类。

3.1尝试获取锁

在下面的示例中，我们有两个线程，试图获取相同的两个锁。

一个线程获取lock2 ，然后阻止尝试获取lock1 ： 

public void lockBlocking() {
    LOGGER.info("{}|Trying to acquire lock2...", Thread.currentThread().getName());
    lock2.lock();
    try {
        LOGGER.info("{}|Lock2 acquired. Trying to acquire lock1...", Thread.currentThread().getName());
        lock1.lock();
        LOGGER.info("{}|Both locks acquired", Thread.currentThread().getName());
    } finally {
        lock1.unlock();
        lock2.unlock();
    }
}

另一个线程获取lock1 ，然后尝试获取lock2 。 

public void lockWithTry() {
    LOGGER.info("{}|Trying to acquire lock1...", Thread.currentThread().getName());
    lock1.lock();
    try {
        LOGGER.info("{}|Lock1 acquired. Trying to acquire lock2...", Thread.currentThread().getName());
        boolean acquired = lock2.tryLock(4, TimeUnit.SECONDS);
        if (acquired) {
            try {
                LOGGER.info("{}|Both locks acquired", Thread.currentThread().getName());
            } finally {
                lock2.unlock();
            }
        }
        else {
            LOGGER.info("{}|Failed acquiring lock2. Releasing lock1", Thread.currentThread().getName());
        }
    } catch (InterruptedException e) {
        //handle interrupted exception
    } finally {
        lock1.unlock();
    }
}

使用标准锁定方法，这将导致死锁，因为每个线程将永远等待另一个线程释放该锁。 但是，这次我们尝试使用tryLock指定超时来获取它。 如果四秒钟后仍未成功，它将取消操作并释放第一把锁。 这将允许另一个线程解锁并获得两个锁。

让我们看完整的例子： 

public class TryLock {
    private static final Logger LOGGER = LoggerFactory.getLogger(TryLock.class);
    private final ReentrantLock lock1 = new ReentrantLock();
    private final ReentrantLock lock2 = new ReentrantLock();
    
    public static void main(String[] args) {
        TryLock app = new TryLock();
        Thread t1 = new Thread(new Worker1(app), "Thread-1");
        Thread t2 = new Thread(new Worker2(app), "Thread-2");
        t1.start();
        t2.start();
    }
    
    public void lockWithTry() {
        LOGGER.info("{}|Trying to acquire lock1...", Thread.currentThread().getName());
        lock1.lock();
        try {
            LOGGER.info("{}|Lock1 acquired. Trying to acquire lock2...", Thread.currentThread().getName());
            boolean acquired = lock2.tryLock(4, TimeUnit.SECONDS);
            if (acquired) {
                try {
                    LOGGER.info("{}|Both locks acquired", Thread.currentThread().getName());
                } finally {
                    lock2.unlock();
                }
            }
            else {
                LOGGER.info("{}|Failed acquiring lock2. Releasing lock1", Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
            //handle interrupted exception
        } finally {
            lock1.unlock();
        }
    }
    
    public void lockBlocking() {
        LOGGER.info("{}|Trying to acquire lock2...", Thread.currentThread().getName());
        lock2.lock();
        try {
            LOGGER.info("{}|Lock2 acquired. Trying to acquire lock1...", Thread.currentThread().getName());
            lock1.lock();
            LOGGER.info("{}|Both locks acquired", Thread.currentThread().getName());
        } finally {
            lock1.unlock();
            lock2.unlock();
        }
    }
    
    private static class Worker1 implements Runnable {
        private final TryLock app;
        
        public Worker1(TryLock app) {
            this.app = app;
        }
        
        @Override
        public void run() {
            app.lockWithTry();
        }
    }
    
    private static class Worker2 implements Runnable {
        private final TryLock app;
        
        public Worker2(TryLock app) {
            this.app = app;
        }
        
        @Override
        public void run() {
            app.lockBlocking();
        }
    }
}

如果执行代码，将产生以下输出： 

13:06:38,654|Thread-2|Trying to acquire lock2...
13:06:38,654|Thread-1|Trying to acquire lock1...
13:06:38,655|Thread-2|Lock2 acquired. Trying to acquire lock1...
13:06:38,655|Thread-1|Lock1 acquired. Trying to acquire lock2...
13:06:42,658|Thread-1|Failed acquiring lock2. Releasing lock1
13:06:42,658|Thread-2|Both locks acquired

在第四行之后，每个线程都已获取一个锁，并且在尝试获取另一个锁时被阻塞。 在下一行，您会注意到四秒钟的间隔。 自超时以来，第一个线程无法获取锁并释放它已经获取的锁，从而允许第二个线程继续。

4. ReentrantReadWriteLock

这种类型的锁保留一对内部锁（ ReadLock和WriteLock ）。 如接口所述，此锁允许多个线程同时从资源读取。 当资源具有频繁读取但很少写入的资源时，这特别方便。 只要没有需要写的线程，资源就将被并发访问。

以下示例显示了三个线程同时从共享资源读取。 当第四个线程需要写入时，它将排他地锁定资源，从而防止读取线程在写入时访问该资源。 一旦写入完成并释放了锁定，所有读取器线程将继续并发访问资源： 

public class ReadWriteLockExample {
    private static final Logger LOGGER = LoggerFactory.getLogger(ReadWriteLockExample.class);
    final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Data data = new Data("default value");
    
    public static void main(String[] args) {
        ReadWriteLockExample example = new ReadWriteLockExample();
        example.start();
    }
    
    private void start() {
        ExecutorService service = Executors.newFixedThreadPool(4);
        for (int i=0; i<3; i++) service.execute(new ReadWorker());
        service.execute(new WriteWorker());
        service.shutdown();
    }
    
    class ReadWorker implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 2; i++) {
                readWriteLock.readLock().lock();
                try {
                    LOGGER.info("{}|Read lock acquired", Thread.currentThread().getName());
                    Thread.sleep(3000);
                    LOGGER.info("{}|Reading data: {}", Thread.currentThread().getName(), data.getValue());
                } catch (InterruptedException e) {
                    //handle interrupted
                } finally {
                    readWriteLock.readLock().unlock();
                }
            }
        }
    }
    
    class WriteWorker implements Runnable {
        @Override
        public void run() {
            readWriteLock.writeLock().lock();
            try {
                LOGGER.info("{}|Write lock acquired", Thread.currentThread().getName());
                Thread.sleep(3000);
                data.setValue("changed value");
                LOGGER.info("{}|Writing data: changed value", Thread.currentThread().getName());
            } catch (InterruptedException e) {
                //handle interrupted
            } finally {
                readWriteLock.writeLock().unlock();
            }
        }
    }
}

控制台输出显示结果： 

11:55:01,632|pool-1-thread-1|Read lock acquired
11:55:01,632|pool-1-thread-2|Read lock acquired
11:55:01,632|pool-1-thread-3|Read lock acquired
11:55:04,633|pool-1-thread-3|Reading data: default value
11:55:04,633|pool-1-thread-1|Reading data: default value
11:55:04,633|pool-1-thread-2|Reading data: default value
11:55:04,634|pool-1-thread-4|Write lock acquired
11:55:07,634|pool-1-thread-4|Writing data: changed value
11:55:07,634|pool-1-thread-3|Read lock acquired
11:55:07,635|pool-1-thread-1|Read lock acquired
11:55:07,635|pool-1-thread-2|Read lock acquired
11:55:10,636|pool-1-thread-3|Reading data: changed value
11:55:10,636|pool-1-thread-1|Reading data: changed value
11:55:10,636|pool-1-thread-2|Reading data: changed value

如您所见，当编写器线程获得写锁定（线程4）时，其他任何线程都无法访问该资源。

5.结论

这篇文章展示了显式锁的主要实现方式，并解释了与隐式锁有关的一些改进功能。 这篇文章是Java Concurrency Tutorial系列的一部分。 检查此处以阅读本教程的其余部分。

翻译自: https://www.javacodegeeks.com/2015/02/java-concurrency-tutorial-locking-explicit-locks.html

dnc8371
关注
七、输入输出系统：用锁实现输出、编写键盘驱动程序、环形输入缓冲区
zhangyang249的博客
12-02 689
锁 多线程调度中出现了字符乱象，本质是访问公共资源需要很多步操作，但是这些操作不具备原子性，它被任务调度器给断开了，从而让其他线程有机会去破坏显存和光标寄存器这两类公共资源。 公共资源：公共内存、公共文件、公共硬件等，我们这里的是显存和光标寄存器 临界区：各个任务中访问公共资源的指令代码组成的区域就是临界区，，强调一下，临界区是指程序中那些访问公共资源的代码，即临界区是指令代码。 互斥：指
Java并发编程之显式锁机制详解
08-29
Java并发编程中的显式锁机制是比`synchronized`关键字更为灵活的一种同步控制方式。显式锁允许程序员更精细地控制锁的获取与释放，从而在某些复杂场景下提供更高的性能和更多的功能。本文将深入探讨Java中Lock接口...
[MySQL] mysql 的行级显式锁定和悲观锁
程序员老狼专注开发aigc或客服系统应用
04-08 121
隐式和显式锁定:1.innodb是两阶段锁定协议,隐式锁定比如在事务的执行过程中.会进行锁定,锁只有在commit或rollback的时候,才会同时被释放2.特定的语句进行显式锁定 select ... lock in share mode ; select ... for update,where条件里面的必须是主键,否则会锁整张表3.需要用在事务中使用,并且两个查询都需要for ...
解析Concurrent包下的ReentrantLock、LockSupport、AQS
SmuEdward的博客
02-14 1022
本文转自老马编程，微信公众号：laoma_shuoJava并发包中的显式锁接口和类位于包java.util.concurrent.locks下，主要接口和类有： 锁接口Lock，主要实现类是ReentrantLock 读写锁接口ReadWriteLock，主要实现类是ReentrantReadWriteLock本节主要介绍接口Lock和实现类ReentrantLock，关于读写锁，我们后续章节介
java 并发锁_Java并发教程–锁定：内在锁
最佳 Java 编程
06-17 148
java 并发锁 在之前的文章中，我们回顾了在不同线程之间共享数据的一些主要风险（例如原子性和可见性 ）以及如何设计类以安全地共享（ 线程安全的设计 ）。 但是，在许多情况下，我们将需要共享可变数据，其中一些线程将写入而其他线程将充当读取器。 可能的情况是，只有一个域，与其他域无关，需要在不同线程之间共享。 在这种情况下，您可以使用原子变量。 对于更复杂的情况，您将需要同步。 1.咖啡店的...
Java并发编程：显式锁Lock
技术zhai的博客
07-26 205
Lock显式锁是在JDK1.5引入的，在JDK1.5之前处理多线程并发使用的是synchronized和volatile关键字。在JDK1.5之后增加了一种新的机制Lock，虽然与synchronized类似都是提供加锁机制，但是Lock锁并不是提供了一种替代内置锁synchronized的方式，而是当内置锁机制不适用时，提供了一种可选择的更高级的功能。 synchronized的局限性 sy...
Java 8并发教程：同步和锁定
纸上得来终觉浅，绝知此事要躬行
05-25 1124
欢迎来到我的Java 8并发教程的第二部分，在一系列指导教程中使用Java 8中的多线程编程与易于理解的代码示例。在接下来的15分钟内，您将学习如何通过synchronized关键字，锁和信号量同步对可变共享变量的访问。
Java并发教程–重入锁
最佳 Java 编程
05-07 86
Java的synced关键字是一个很棒的工具–它使我们能够以一种简单可靠的方式来同步对关键部分的访问，而且也不难理解。 但是有时我们需要对同步进行更多控制。 我们要么需要分别控制访问类型（读取和写入），要么使用起来很麻烦，因为要么没有明显的互斥锁，要么我们需要维护多个互斥锁。 值得庆幸的是，Java 1.5中添加了锁实用程序类，使这些问题更易于解决。 Java重入锁 Java在...
探索Java并发的基石：同步机制的全面解析
07-16
4. **原子类**：如`AtomicInteger`，提供了一种无需显式锁定就能保证线程安全的操作方式。原子类利用CAS（Compare and Swap）操作来实现线程安全。 ```java import java.util.concurrent.atomic.AtomicInteger; ...
Java并发编程调试秘诀：诊断和解决并发问题
[Java并发编程调试秘诀：诊断和解决并发问题](https://img-blog.csdnimg.cn/20210508172021625.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3...
【Java并发编程艺术】：线程池与锁的高级技巧，提升并发性能
Java并发编程是构建高效、稳定应用的核心技术之一。在现代软件开发中，良好的并发处理能够显著提升程序的执行效率和用户体验。本章将为您介绍并发编程的基础知识，并重点讲解Java中的并发工具类。 ## 1.1 Java并发...
【Java并发控制指南】：同步与并发修饰符的正确使用
Java并发基础与并发问题概述 ## 1.1 并发编程的定义 在计算机科学中，并发编程是实现多任务同时进行的一种编程范式。在Java中，它允许开发人员编写能够同时处理多个操作的程序。随着多核处理器的普及，合理利用...
mysql 隐式和显式锁定
每天进步一点点儿
12-25 1605
InnoDB采用两阶段锁定协议，在事务执行过程中，随时都可以执行锁定，锁只有在执行commit或rollback的时候才会释放，并且所有的锁是在同一时刻被释放的，前面所述的锁定是隐式锁定，InnoDB会根据事务的隔离级别在需要的时候自动加锁。 SELECT ... LOCK IN SHARE MODE SELECT ... FOR UPDATE 这些语句可以执行显式锁定，但是不属于sq...
mysql的隐式锁定和显式锁定
wangkai6666的博客
01-15 386
隐式锁和显式锁
显式锁与隐式锁的区别
Shalick的书架
10-19 1193
显式锁与隐式锁的区别 解决的方法 格式 描述 同步代码块(关键字) synchronized(锁对象){} 隐式锁，多个线程的锁对象必须唯一 同步方法(修饰符) synchronized 返回类型 方法名(){} 隐式锁，谁调用该方法谁就是锁对象 显示锁 ReentrantLock类的lock()/unlock()方法 显式锁，有程序员决定在那开启/关闭锁 一、构成不同 Sync 和 Lock 的出身（原始的构成）不同： Sync：Java中的关键字，是由JVM来维护的。是J
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 408
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 733
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 511
spring boot 整合 mybatis
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1180
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java并发编程面试精华：JUC面试题与多线程解析
"这篇文章是关于Java并发编程的面试指南，主要涵盖了周阳老师的面试教程中的JUC（java.util.concurrent）部分，包含了大量的面试题和实际应用案例。文章旨在帮助求职者准备大厂面试，并且适用于那些希望提升并发编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值