Java 并发编程实战 -- 锁

最新推荐文章于 2024-08-20 10:17:01 发布
最新推荐文章于 2024-08-20 10:17:01 发布
阅读量507 收藏
点赞数
分类专栏： Java 并发编程实战 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42480750/article/details/125386079
版权
本文详细介绍了Java中的显式锁，包括轮询锁、定时锁、中断锁、公平锁和读写锁的使用，并通过实例展示了如何避免死锁，如锁顺序和协作对象死锁的问题。内容涵盖了Lock接口、ReentrantLock类以及公平与非公平锁的概念，强调了正确使用锁以提高并发性能和避免死锁的重要性。
摘要由CSDN通过智能技术生成

文章目录

一、显式锁

  • 简介
  1. Lock 提供了一种无条件的、可轮询的、定时的以及可中断的锁获取操作，所有加锁和解锁的方法都是显式的。
public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}
  1. Lock 并不是一种替代内置加锁的方法，而是当内置加锁机制不适用时，作为一种可选择的高级功能。

在这里插入图片描述

  1. 内置锁无法中断一个正在等待获取锁的线程，无法实现非阻塞结构的加锁规则。
  2. Lock 提供与 synchronized 相同的互斥性和内存可见性、可重入、更灵活，但需要手动加锁与释放：
    Lock lock = new ReentrantLock();
    ...
    lock.lock();
    try {
        // 更新对象状态，捕获异常并在必要时恢复不变性条件
    } finally {
        // 程序的执行控制离开被保护的代码块时不会自动清除锁，切记在 finally 中释放 Lock
        lock.unlock();
    }

1.1 轮询锁

通过 tryLock 实现：如果不能获得所有需要的锁，释放已经获得锁，然后重新尝试获取所有锁。

    public boolean transferMoney(Account fromAcct, Account toAcct, DollarAmount amount,
    			long timeout, TimeUnit unit) 
                throws InsufficientFundsExeception, InterruptedException {
        long fixedDelay = getFixedDelayComponentNanos(timeout, unit);
        long randMod = getRandomDelayModulusNanos(timeout, unit);
        long stopTime = System.nanoTime() + unit.toNanos(timeout);
        while (true) {
            if (fromAcct.lock.tryLock()) {
                try {
                    if (toAcct.lock.tryLock()) {
                        try {
                            if (fromAcct.getBalance().compareTo(amount) < 0) {
                                throw new InsufficientFundsExeception();
                            } else {
                                fromAcct.debit(amount);
                                toAcct.credit(amount);
                                return true;
                            }
                        } finally {
                            toAcct.lock.unlock();
                        }
                    }
                } finally {
                    fromAcct.lock.unlock();
                }
            }

            if (System.nanoTime() < stopTime)
                return false;
            NANOSECONDS.sleep(fixedDelay + rnd.nextLong() % randMod);
        }
    }

1.2 定时锁

通过 tryLock 实现：如果操作不能在指定的时间内给出结果，那么就会使程序提前结束。

    public boolean trySendOnSharedLine(String message, long timeout, TimeUnit unit)
            throws InterruptedException {
        long nanosToLock = unit.toNanos(timeout) - estimatedNanosToSend(message);
        if (!lock.tryLock(nanosToLock, NANOSECONDS))
            return false;
        try {
            return sendOnSharedLine(message);
        } finally {
            lock.unlock();
        }
    }

1.3 中断锁

Lock 类中提供了 lockInterruptibly方法，该方法允许在等待一个锁的同时仍能响应中断。

public class InterruptibleLocking {
    private Lock lock = new ReentrantLock();

    public boolean sendOnSharedLine(String message)
            throws InterruptedException {
        lock.lockInterruptibly();
        try {
            return cancellableSendOnSharedLine(message);
        } finally {
            lock.unlock();
        }
    }

    private boolean cancellableSendOnSharedLine(String message) throws InterruptedException {
        /* send something */
        return true;
    }

}

1.4 公平锁

通过 new ReentrantLock​(true) 实现，默认创建的都是非公平锁。

  1. 在公平的锁上，线程将按照它们发出请求的顺序来获得锁。
  2. 在非公平的锁上，如果发出请求的同时该锁的状态变为可用，那么这个线程将跳过队列中所有等待的线程并获得这个锁。
  3. 线程挂起和恢复的开销很大，无需必要请使用默认的非公平锁：

在这里插入图片描述

1.5 读写锁

互斥是一种过于保守的、强硬的加锁策略，有时会不必要的限制并发性。

  1. 读写锁的策略是：允许多个读操作同时进行，但每次只允许一个写操作。
public interface ReadWriteLock {
    Lock readLock();
    Lock writeLock();
}

public class ReadWriteMap<K, V> {
    private final Map<K, V> map;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock r = lock.readLock();
    private final Lock w = lock.writeLock();

    public ReadWriteMap(Map<K, V> map) {
        this.map = map;
    }

    public V put(K key, V value) {
        w.lock();
        try {
            return map.put(key, value);
        } finally {
            w.unlock();
        }
    }

    public V get(K key) {
        r.lock();
        try {
            return map.get(key);
        } finally {
            r.unlock();
        }
    }

}

在这里插入图片描述

二、死锁

2.1 锁顺序死锁

在这里插入图片描述

  • 问题引出
    public static void transferMoney(Account fromAccount,
                                     Account toAccount,
                                     DollarAmount amount)
            throws InsufficientFundsException {
        synchronized (fromAccount) {
            synchronized (toAccount) {
                if (fromAccount.getBalance().compareTo(amount) < 0)
                    throw new InsufficientFundsException();
                else {
                    fromAccount.debit(amount);
                    toAccount.credit(amount);
                }
            }
        }
    }
  • 问题解决：保证获取锁的顺序
public class InduceLockOrder {
    private static final Object tieLock = new Object();

    public void transferMoney(final Account fromAcct, final Account toAcct, final DollarAmount amount)
            throws InsufficientFundsException {

        class Helper {
            public void transfer() throws InsufficientFundsException {
                if (fromAcct.getBalance().compareTo(amount) < 0)
                    throw new InsufficientFundsException();
                else {
                    fromAcct.debit(amount);
                    toAcct.credit(amount);
                }
            }
        }

        int fromHash = System.identityHashCode(fromAcct);
        int toHash = System.identityHashCode(toAcct);
        if (fromHash < toHash) {
            synchronized (fromAcct) {
                synchronized (toAcct) {
                    new Helper().transfer();
                }
            }
        } else if (fromHash > toHash) {
            synchronized (toAcct) {
                synchronized (fromAcct) {
                    new Helper().transfer();
                }
            }
        } else {
            synchronized (tieLock) {
                synchronized (fromAcct) {
                    synchronized (toAcct) {
                        new Helper().transfer();
                    }
                }
            }
        }
    }
}

2.2 协作对象死锁

如果在持有锁时调用某个外部方法，那么将出现活跃性问题。在这个外部方法中可能会获取到其它锁（这可能产生死锁），或者阻塞时间过长，导致其它线程无法及时获得当前被持有的锁。

  • 问题引出
public class CooperatingDeadlock {
    class Taxi {
        @GuardedBy("this") private Point location, destination;
        private final Dispatcher dispatcher;

        public Taxi(Dispatcher dispatcher) {
            this.dispatcher = dispatcher;
        }

        public synchronized Point getLocation() {
            return location;
        }

        // 先尝试获取 Taxi 锁
        public synchronized void setLocation(Point location) {
            this.location = location;
            if (location.equals(destination))
                dispatcher.notifyAvailable(this); // 再尝试获取 Dispatcher 锁
        }

        public synchronized Point getDestination() {
            return destination;
        }

        public synchronized void setDestination(Point destination) {
            this.destination = destination;
        }
    }

    class Dispatcher {
        @GuardedBy("this") private final Set<Taxi> taxis;
        @GuardedBy("this") private final Set<Taxi> availableTaxis;

        public Dispatcher() {
            taxis = new HashSet<Taxi>();
            availableTaxis = new HashSet<Taxi>();
        }

        public synchronized void notifyAvailable(Taxi taxi) {
            availableTaxis.add(taxi);
        }

        // 先尝试获取 Dispatcher 锁
        public synchronized Image getImage() {
            Image image = new Image();
            for (Taxi t : taxis)
                image.drawMarker(t.getLocation()); // 再尝试获取 Taxi 锁
            return image;
        }
    }
}
  • 开放调用：如果在调用某个方法时不需要持有锁，那么这种调用称为开放调用。
class CooperatingNoDeadlock {
    @ThreadSafe
    class Taxi {
        @GuardedBy("this") private Point location, destination;
        private final Dispatcher dispatcher;

        public Taxi(Dispatcher dispatcher) {
            this.dispatcher = dispatcher;
        }

        public synchronized Point getLocation() {
            return location;
        }

        public synchronized void setLocation(Point location) {
            boolean reachedDestination;
            synchronized (this) { // 减小锁的范围
                this.location = location;
                reachedDestination = location.equals(destination);
            }
            if (reachedDestination)
                dispatcher.notifyAvailable(this);
        }

        public synchronized Point getDestination() {
            return destination;
        }

        public synchronized void setDestination(Point destination) {
            this.destination = destination;
        }
    }

    @ThreadSafe
    class Dispatcher {
        @GuardedBy("this") private final Set<Taxi> taxis;
        @GuardedBy("this") private final Set<Taxi> availableTaxis;

        public Dispatcher() {
            taxis = new HashSet<Taxi>();
            availableTaxis = new HashSet<Taxi>();
        }

        public synchronized void notifyAvailable(Taxi taxi) {
            availableTaxis.add(taxi);
        }

        public Image getImage() {
            Set<Taxi> copy;
            synchronized (this) { // 减小锁的范围
                copy = new HashSet<Taxi>(taxis);
            }
            Image image = new Image();
            for (Taxi t : copy)
                image.drawMarker(t.getLocation());
            return image;
        }
    }
}
L小Ray想有腮
关注
专栏目录
Java中的锁实战
实践求真知
06-20 494
一对某个对象加锁 //锁的是对象，不是代码 public class T { private int count = 10; private Object o = new Object(); public void m() { // 任何线程要执行下面的代码，必须先拿到 o 的锁，只有拿到 o 这把锁，才能执行下面这段代码。 // 一旦 A 线程拿到这把锁，B 线程只有等 A 线程执行完，释放了 o 这把锁，B 再获取这把锁，B...
java并发编程实战源码-jcip-examples:java并发编程实战
05-25
《Java并发编程实战》是Java并发编程领域的一本经典之作，由Brian Goetz等作者撰写。这本书深入浅出地介绍了Java并发编程的各种概念和技术，帮助开发者理解和掌握如何在多线程环境中编写高效、安全的代码。jcip-...
【Java并发编程实战】—–“J.U.C”：锁，lock
chenssy 的技术博客
08-10 5773
在java中有两种方法实现锁机制，一种是在前一篇博客中（【java7并发编程实战】—–线程同步机制：synchronized）介绍的synchronized，而另一种是比synchronized更加强大和领过的Lock。Lock确保当一个线程位于代码的临界区时，另一个线程不进入临界区，相对于synchronized，Lock接口及其实现类提供了更加强大、灵活的锁机制。一个简单的锁在使用synchr
JAVA并发编程实战
最新发布
weixin_46896387的博客
08-20 467
synchronized 的问题是，持有锁 A 后，如果尝试获取锁 B 失败，那么线程就进入阻塞状态，一旦发生死锁，就没有任何机会来唤醒阻塞的线程。但如果阻塞状态的线程能够响应中断信号，也就是说当我们给阻塞的线程发送中断信号的时候，能够唤醒它，那它就有机会释放曾经持有的锁 A。接收方处理请求时进行IO操作如果不能马上得到结果，就一直等到返回结果后，才响应发送方，期间不能进行其他操作。接收方处理请求时进行的IO操作如果不能马上等到返回结果，就一直等到返回结果后，才响应发送方，期间不能进行其他工作。
java 单例 读写锁_终极锁实战：单JVM锁+分布式锁
weixin_39845613的博客
02-16 388
目录1.前言2.单JVM锁3.分布式锁4.总结=========正文分割线=================1.前言锁就像一把钥匙，需要加锁的代码就像一个房间。出现互斥操作的典型场景：多人同时想进同一个房间争抢这个房间的钥匙(只有一把)，一人抢到钥匙，其他人都等待这个人出来归还钥匙，此时大家再次争抢钥匙循环下去。作为终极实战系列，本篇用java语言分析锁的原理(源码剖析)和应用(详细代码)，根据锁...
Java中死锁实战
实践求真知
05-28 306
一点睛 当两个线程相互等待对方释放同步监视器时就会发生死锁，Java虚拟机没有监测、也没有采用措施来处理死锁情况，所以多线程编程时应该采取措施避免死锁的出现。 一旦出现死锁，整个程序既不会发生任何异常，也不会给出任何提示，只是所有线程处于阻塞状态，无法继续。 二代码 class A { public synchronized void foo( B b ) { ...
Java并发编程之Lock锁详解与实战
qq_43372633的博客
05-19 429
ReentrantLock，NonReentrantLock，ReentrantReadWriteLock等Lock详解与实战
java并发编程实战源码-concurrent-programming:《Java并发编程实战》源码整理
05-25
《Java并发编程实战》这本书是Java并发编程领域的一本经典之作，它深入浅出地讲解了如何在Java环境中高效、安全地进行多线程编程。源码整理集合`concurrent-programming-master`提供了书中示例代码，对于学习和理解...
读书笔记-Java并发编程实战-基础篇
08-09
在Java并发编程中，数据的封装与访问控制、线程安全性的考量、同步机制的使用是重要的基础概念和技巧。以下是从给出的文件内容中提取出的详细知识点： 1. 数据封装与访问控制：确保内部私有数据不被轻易访问，并且...
java并发编程实战源码,java并发编程实战pdf,Java
09-10
《Java并发编程实战》是Java并发编程领域的一本经典著作，它深入浅出地介绍了如何在Java平台上进行高效的多线程编程。这本书的源码提供了丰富的示例，可以帮助读者更好地理解书中的理论知识并将其应用到实际项目中。...
JAVA Lock加锁实例
07-10
Lock锁是对象锁，仅在同一对象中，锁才会生效。（不做论证） （以下场景皆为单例模式下运行） lock.lock()的加锁方式，会使后续请求的线程堵塞等待。（方案A） lock.tryLock()的加锁方式，不会堵塞，会立即返回加锁成功与否。（方案AEX） lock.tryLock(1000, TimeUnit.SECONDS)的加锁方式，允许堵塞时间，若在堵……
JAVA并发编程实战-显式锁
qq_36566262的博客
05-08 551
目录思维导图1 Lock和ReentrantLock1.1 可轮询的和可定时的锁1.2 可中断的锁获取操作2 对性能的考量3 公平性4 在内部锁synchronized和ReentrantLock直接进行选择5 读写锁总结参考文献 思维导图 1 Lock和ReentrantLock Lock定义了抽象的锁操作，如下图 Lock提供了无条件的、可中断的、可轮询的和定时的获取锁操作。 Lock的实现与内部锁具有相同的内存可见性语义。 ReentrantLock实现了Lock接口，提供了与synchron
java 锁_Java项目实践，锁机制学习，sql锁与方法锁
weixin_39928686的博客
12-02 148
1、sql锁：悲观锁：就是考虑问题很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁；实现：sql语句后边加上for update例子：Select id,nam from biao for update乐观锁:就是考虑问题很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁实现：在表里边加一个vesion例子：Select max(nub) ,version fro...
Java死锁实战演示
振宇的博客
09-26 156
死锁 利用synchronized的锁中锁实现对两个资源的争夺，实现死锁！ package jess.day07; /** * @author Jess * @date 2021/9/26 */ public class DeadLock { // 创建两个object锁 private static final Object OBJECT1 = new Object(); private static final Object OBJECT2 = new Object(
Java Lock最佳实践
编程碎碎念
09-27 308
在进行并发操作时，通常需要加锁操作来保证一致性。Java类库中提供了几种用于替代synchronized的锁，比如ReentrantLock，具体实现可能还有基于Redis等其他形式的锁，在JDK官方文档中，给出了加锁的最佳实践： 正确加锁操作 Lock l = ...; l.lock(); try { // access the resource protected by this lock } finally { l.unlock(); } unlock操作放在finally无可厚非，这里主要
Java并发编程实战~Lock
小强快跑~~
11-27 179
再造管程的理由 synchronized导致死锁问题，提出了一个破坏不可抢占条件方案，但是这个方案 synchronized 没有办法解决。原因是 synchronized 申请资源的时候，如果申请不到，线程直接进入阻塞状态了，而线程进入阻塞状态，啥都干不了，也释放不了线程已经占有的资源。但我们希望的是： 对于“不可抢占”这个条件，占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源，这样不可抢占这个条件就破坏掉了。 如果我们重新设计一把互斥锁去解决这个问题，那该怎么设计呢
Java LockSupport 实战
实践求真知
06-26 181
一代码 package com.mashibing.juc.c_020; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.LockSupport; public class T13_TestLockSupport { public static void main(String[] args) { Thread t = new Thread(() -> { .
Java并发编程实战笔记 （四）锁
qq_31887989的博客
11-29 286
时，会尝试获取对象的锁，如果锁的计数器为 0 则表示锁可以被获取，获取后将锁计数器设为 1 也就是加 1。主要解决的是多个线程之间访问资源的同步性，可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。在java虚拟机中，锁获取的是对象监视器 monitor,在执行。指令后，将锁计数器设为 0，表明锁被释放，其他线程可以尝试获取锁。访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。提供了一种无条件的、可轮询的、定时的以及可中断的锁获取操作。标识，该标识指明了该方法是一个同步方法。
Java并发编程实战：ReentrantLock与读写锁详解
Java并发编程实践的第七章深入探讨了Java5.0引入的高级锁定机制，特别是重入锁（ReentrantLock）和读写锁，这对于理解和优化多线程编程至关重要。这一章节首先介绍了Lock接口及其与内置锁的区别，Lock提供了一系列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值