java--Lock锁

最新推荐文章于 2024-09-21 09:48:09 发布
最新推荐文章于 2024-09-21 09:48:09 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： java并发编程 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adminBfl/article/details/130382519
版权
文章介绍了Java中Lock接口与synchronized关键字在多线程同步中的区别和使用场景。Lock提供了更细粒度的控制，如tryLock(),LockInterruptibly()，能更灵活地处理锁的获取和释放，同时在finally块中释放锁以防止死锁。通过示例展示了如何使用tryLock避免死锁问题以及LockInterruptibly()方法在等待锁时支持中断。
摘要由CSDN通过智能技术生成

1.概述

锁是一种工具，用于控制对共享资源的访问

Lock和synchronized，这两个是最常见的锁，它们都可以达到线程安全的目的，但是在使用上和功能上又有较大的不同。

Lock并不是用来代替synchronized的，而是当使用synchronized不合适或不足以满足要求的时候，来提供高级功能的。

Lock接口最常见的实现类，是ReentrantLook

通常情况下，Lock只允许一个线程来访问这个共享资源，不过有时候，一些特殊的实现也可允许并发访问。比如，ReadWriteLock里面的ReadLock。

  • 为什么synchronized不够用

1.效率低：所得释放情况少，试图获得锁的时候不能设定超时，不能中断一个正在试图获得锁的线程

2.不够灵活：枷锁和释放锁时机单一，每个所仅有单一的条件某个对象，可能是不够的。

2Lock锁的主要方法介绍

  • 在lock声明了四个方法来获取锁
  • lock（），tryLock（），tryLock(long time，TimeUnit unit)和LockInterruptibly()

3lock()

lock()就是最普通的获取锁。如果锁已被其他线程获取，则进行等待

Lock()不会像synchronized一样在异常时自动释放锁

因此最佳实践是，在finally中释放锁，以保证发生异常时锁一定被释放

package cn.butool.lock;

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

/**
 * Lock()不会像synchronized一样在异常时自动释放锁
 * 因此最佳实践是，在finally中释放锁，以保证发生异常时锁一定被释放
 */
public class MustUnLock {
    private static Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        // 加锁
        lock.lock();
        try{
            //获取本锁，保护的资源
            System.out.println(Thread.currentThread().getName()+"开始执行任务");
        }finally {
            // 释放锁
            lock.unlock();
        }
    }
}

 4tryLock()、tryLock(long time，TimeUnit unit)

  1. lock()方法不能被中断，一旦陷入死锁，这会带来很大的隐患lock()就会陷入永久等待 ；
  2. tryLock()用来尝试获取锁，如果当前锁没有被其他线程占用，则获取成功，则返回true，否则返回false，代表获取锁失败。
  3. 该方法会立即返回，即便在拿不到锁时不会一直在那等
  4. tryLock(long time，TimeUnit unit)超时就放弃

5用tryLock来避免死锁

5.1代码

package cn.butool.lock;

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

/**
 * 用TryLock来避免死锁
 */
public class TryLockDeadLock implements Runnable{

    public static void main(String[] args) {
        TryLockDeadLock r1 = new TryLockDeadLock();
        TryLockDeadLock r2 = new TryLockDeadLock();
        r1.flag=1;
        r2.flag=0;
        new Thread(r1).start();
        new Thread(r2).start();
    }
    int flag =1;
    static Lock locl1 = new ReentrantLock();
    static Lock locl2 = new ReentrantLock();
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(flag ==1){
                try {
                    if(locl1.tryLock(800, TimeUnit.MILLISECONDS)){
                        try {
                            System.out.println("线程1获取到了锁1");
                            Thread.sleep(new Random().nextInt(1000));

                            if(locl2.tryLock(800, TimeUnit.MILLISECONDS)){
                                try{
                                    System.out.println("线程1获取到了锁2");
                                    System.out.println("线程1获取到了2把锁");
                                    break;
                                }finally {
                                    locl2.unlock();
                                }
                            }else{
                                System.out.println("线程1获取锁2失败，已重试");
                            }

                        }finally {
                            locl1.unlock();
                            Thread.sleep(new Random().nextInt(1000));
                        }
                    }else{
                        System.out.println("线程1获取锁1失败，已重试");
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            if(flag ==0){
                try {
                    if(locl2.tryLock(3000, TimeUnit.MILLISECONDS)){
                        try {
                            System.out.println("线程2获取到了锁2");
                            Thread.sleep(new Random().nextInt(1000));

                            if(locl1.tryLock(800, TimeUnit.MILLISECONDS)){
                                try{
                                    System.out.println("线程2获取到了锁1");
                                    System.out.println("线程2获取到了2把锁");
                                    break;
                                }finally {
                                    locl1.unlock();
                                }
                            }else{
                                System.out.println("线程2获取锁1失败，已重试");
                            }

                        }finally {
                            locl2.unlock();
                            Thread.sleep(new Random().nextInt(1000));
                        }
                    }else{
                        System.out.println("线程2获取锁1失败，已重试");
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

5.2打印

线程1获取到了锁1
线程2获取到了锁2
线程2获取锁1失败，已重试
线程1获取到了锁2
线程1获取到了2把锁
线程2获取到了锁2
线程2获取到了锁1
线程2获取到了2把锁

 6LockInterruptibly()

 相当于tryLock(long time, TimeUnit unit)把超时时间设置为无限。在等待锁的过程中，线程可以被中断

6.1代码

package cn.butool.lock;

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

public class LockInterruptiblyTest implements Runnable{
    public static void main(String[] args) {
        LockInterruptiblyTest lockInterruptiblyTest = new LockInterruptiblyTest();
        Thread thread1 = new Thread(lockInterruptiblyTest);
        Thread thread2 = new Thread(lockInterruptiblyTest);
        thread1.start();
        thread2.start();
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread1.interrupt();
    }
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"尝试获取锁");
        try {
            lock.lockInterruptibly();
            try {
                System.out.println(Thread.currentThread().getName()+"拿到了锁");

                Thread.sleep(5000);
            }catch (Exception e){
                System.out.println(Thread.currentThread().getName()+"睡眠期间被中断了");
            }
            finally {
                lock.unlock();
                System.out.println(Thread.currentThread().getName()+"释放了锁");
            }
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName()+"等锁期间被中断了");

        }
    }
}

 6.2打印

第一种情况Thread-1拿到了锁：
Thread-0尝试获取锁
Thread-1尝试获取锁
Thread-1拿到了锁
Thread-0等锁期间被中断了
Thread-1释放了锁

第二种情况Thread-0拿到了锁：
Thread-0尝试获取锁
Thread-1尝试获取锁
Thread-0拿到了锁
Thread-0睡眠期间被中断了
Thread-0释放了锁
Thread-1拿到了锁
Thread-1释放了锁

7unLock()解锁

最应该被写到finally里面，并且是第一时间写到finally里面，否则有可能会漏掉，如果漏掉有可能会使程序陷入死锁。

finally {
    lock.unlock();
    System.out.println(Thread.currentThread().getName()+"释放了锁");
}

8可见性保证

在进入synchronized锁时，会去主存中读取此时的最新数据，退出锁时将当前更新刷新到主存中

lack的加解锁和synchronized有同样的内存语义，也就是说下一个线程加锁后可以看到所有前一个线程解锁前发生的所有操作

 

别浪呀
关注
专栏目录
Java-Lock锁
u014230945的博客
01-10 2343
1、JDK1.5以后，Java提供了Lock同步锁，相对与需要JVM隐士获取和释放锁Synchronized 同步锁，Lock同步锁需要显示获取和释放锁，这就为获取和释放锁提供了更多的灵活性。 2、Lock锁的基本操作通过乐观锁来实现，但是由于Lock锁也会在阻塞的时候被挂起，因此它依然属于悲观锁。 对比Synchronized和Lock如下图 Synchronized Lock 实现方式 ...
java7源码-distributed-lock:分布式锁
06-04
java7 源码 现在面试都会聊聊分布式系统，通常面试官都会从服务框架（Spring Cloud、Dubbo），一路聊到分布式事务、分布式锁、ZooKeeper等知识。今天就来聊聊分布式锁这块的知识，先具体的来看看Redis分布式锁的实现...
java中的Lock锁
热门推荐
纯洁的小魔鬼
07-15 1万+
一. 概述 Lock 是 java.util.concurrent.locks 包 下的接口，Lock 实现提供了比 synchronized 关键字 更广泛的锁操作，它能以更优雅的方式处理线程同步问题。Lock提供了比synchronized更多的功能。 1.Lock和ReadWriteLock是两大锁的根接口，Lock代表实现类是ReentrantLock（可重入锁），ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock。 　2.Lock 接口支...
JAVA基础：Lock锁
最新发布
weixin_65346668的博客
09-21 433
因为synchronized锁在使用时存在着一定的不足，所以在jdk1.5时，提供了一个java 并发 工具包。里面包含了许多与多线程操作相关的工具类，其中就包含了Lock系列。
Java Lock（锁）
{竹子}
01-09 592
0. 目录
java Lock
weixin_34198453的博客
12-06 74
一、Lock锁： 　　Lock是一个接口，Lock需要手动的释放锁，Lock锁可以知道是否成功的获取锁。 二、Lock接口中的方法 　　 　　获取锁：Lock() 、tryLock()、tyrLock(long time,timeUnit unit)、lockInterruptibly() 　　释放锁：unlock() 　　 　四种获取锁方法的区别： 　　1.Lock(...
Java 中的Lock锁
学习笔记
05-26 1万+
Lock锁，可以得到和synchronized一样的效果，即实现原子性、有序性和可见性。 相较于synchronized，Lock锁可手动获取锁和释放锁、可中断的获取锁、超时获取锁。 Lock是一个接口，两个直接实现类：ReentrantLock（重入锁）, ReentrantReadWriteLock（读写锁）。 1.概述 Lock锁，使用时手动获取锁和释放锁，比synchro...
java7源码-spring-boot-starter-lock:spring分布式锁
06-04
java7 源码 分布式锁 - starter 基于redis 的 setnx 实现 和 zk 的分布式锁组件 使用场景： case1: bean注入获取锁 application.properties(yml) 配置相关的lockName, 例如： lock.names = test_lock, demo_lock, ...
redis-distributed-lock:redis分布式锁工具包，提供纯Java方式调用，支持传统Spring工程， 为spring boot应用提供了starter，更方便快捷的调用
05-17
redis分布式锁工具包，提供纯Java方式调用，支持传统Spring工程， 为spring boot应用提供了starter，更方便快捷的调用。 项目结构 原生redis分布式锁实现，支持注解，不推荐项目中使用，仅供学习使用 redis-...
Redission分布式锁-本地单机Redis实战-springboot-redis-lock.zip
01-31
本项目“Redission分布式锁-本地单机Redis实战-springboot-redis-lock”旨在教你如何在SpringBoot项目中集成Redisson库，实现基于Redis的分布式锁功能。下面我们将深入探讨相关的知识点。 1. **Redisson**：...
java lock 锁
张恒的博客
05-13 212
需要手动释放锁 boolean lock.tryLock(long time, TimeUtil util); 尝试申请锁并持续 time , 申请到返回 true void lock.lockInterruptibly() throws InterruptedException; 持续申请锁，效果等同与lock.lock(),但是lockInterruptibly() 可以在主线程取...
Java中Lock锁详解
mercedes_benz
07-08 7433
在Java中，Lock是一个接口，它提供了比关键字更高级的线程同步机制。使用Lock接口可以创建更复杂和灵活的同步结构。Lock接口的常用实现类有ReentrantLock和ReentrantReadWriteLock，它们提供了可重入的互斥锁和读写锁。使用Lock锁的一般步骤如下：1. 创建一个`Lock`对象实例。2. 在需要进行同步的代码块中，通过调用`lock()`方法来获取锁。3. 在同步的代码块执行完之后，通过调用`unlock()`方法释放锁。
Java Lock锁
zz2636733703的博客
04-21 387
java lock锁
死锁
after_17的博客
03-11 93
目录死锁 DeadLock如何破解死锁使用 lambda 表达式简化代码开发Lock Java 默认线程有两个，main（主线程），GC（垃圾回收机制） synchronized 关键字实现线程同步，让在访问同一个资源的多个线程排队去完成业务，避免出现数据错乱的情况。 死锁 DeadLock 前提：一个线程完成业务需要同时访问两个资源。 死锁：多个线程同时在完成业务，出现争抢资源的情况。 资源类 package com.southwind.demo1; public class DeadLockRunna
java lock锁
qq_39306234的博客
11-25 401
private final ReentrntLock lock = new ReenTrantLock(); public void A (){ //加锁 lock.lock(); try{ 保证线程安全的代码； }finally{ //解锁 lcok.unlock() } } synchornized 和 Lock对比
java Lock锁
hu20210623的博客
07-19 91
package com.shisan.gaoji; import java.util.concurrent.locks.ReentrantLock; public class TestLock { public static void main(String[] args) { TestLock2 testLock2 = new TestLock2(); new Thread(testLock2,"z1").start(); new Thread
Java中的Lock锁
Hubuers的博客
03-14 1044
文章目录背景知识具体用法 背景知识 在synchronized实现线程锁中，锁默认是开启的，当线程进入同步代码块/方法之后，锁自动关闭，当线程执行完同步代码块/方法后，锁又自己打开。 这种方法使用简单，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock Lock的实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作 Lock中提供了获得锁和释放锁的方法（手动完成，非自动） void lock()：获得锁 vo
Java—Lock锁
致宁的大博客！
09-29 222
https://blog.csdn.net/weixin_43214609/article/details/101627433 参照上面的博客，得知Synchronized锁是一个重量级的锁，效率很低，而且隐式加解锁，非常不方便。 那么Java中也有一个自己实现的锁机制——Lock锁。 Lock锁是纯用Java实现的，可以看到底层源代码的那种。 1.Lock 在Java中是一个接口，是J...
java lock
weixin_33895657的博客
05-07 109
2019独角兽企业重金招聘Python工程师标准>>> ...
Java多线程Lock锁详解与并发内存模型解析
"Java多线程中Lock锁的使用总结" 在Java多线程编程中，Lock锁是一种比内置的synchronized关键字更为灵活的同步机制。synchronized在某些情况下可能会限制程序的可读性和可扩展性，而Lock接口（位于java.util....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值