java并发编程之Lock和ReentrantLock

最新推荐文章于 2024-09-22 17:11:43 发布
最新推荐文章于 2024-09-22 17:11:43 发布
阅读量180 收藏
点赞数
分类专栏： java java编发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013637451/article/details/102798674
版权

一. Lock，ReentrantLock介绍

了解lock之前可以对比jdk提供的synchronzied，synchronzied也被用于实现线程同步，但是有些场景下并不灵活，如多个同步方法，每次只能有一个线程访问；而Lock则可以非常灵活的在代码中实现同步机制。

Lock 接口的定义

public interface Lock {

     // 获取锁，若当前lock被其他线程获取；则此线程阻塞等待lock被释放
     // 如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁
    void lock();

    // 获取锁，若当前锁不可用（被其他线程获取）;
    // 则阻塞线程，等待获取锁，则这个线程能够响应中断，即中断线程的等待状态
    void lockInterruptibly() throws InterruptedException;

    // 来尝试获取锁，如果获取成功，则返回true；
    // 如果获取失败（即锁已被其他线程获取），则返回false
    // 也就是说，这个方法无论如何都会立即返回
    boolean tryLock();

    // 在拿不到锁时会等待一定的时间
    // 等待过程中，可以被中断
    // 超过时间，依然获取不到，则返回false；否则返回true
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    // 释放锁
    void unlock();

    // 返回一个绑定该lock的Condtion对象
    // 在Condition#await()之前，锁会被该线程持有
    // Condition#await() 会自动释放锁，在wait返回之后，会自动获取锁
    Condition newCondition();
}

ReentrantLock

ReentrantLock是唯一一个实现了Lock的接口的类，叫做可重入锁，意思是拥有锁之后，可以再次获取锁

二.基本使用

1.模拟上下班场景，公司要求A岗位同时只能安排一个人上班；

package com.lhy.jui.tools.lock;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: lihuiyong
 * @DATE : 2019/10/29
 * @version:1.0.0
 * @description: lock 使用场景
 *
 * 模拟保安值班，每次只能一个保安值班
 */
public class LockExample {

    /**
     * 默认创建非公平锁
     */
    private Lock lock = new ReentrantLock();

    private void workIng(){
        System.out.println(Thread.currentThread().getName() +" 上班！");
    }
    private void workOff(){
        System.out.println(Thread.currentThread().getName() +" 下班！");
    }

    public  void work(){
        try{
            lock.lock();
                workIng();
                System.out.println(Thread.currentThread().getName() +"上班中");
                Thread.sleep(100);
                workOff();
        }catch (Exception ex){
            System.out.println(Thread.currentThread().getName()+"无法上班，有人还未下班");
        }finally {
            if(lock != null){
                lock.unlock();
            }
        }
    }

    public  void workTryLock(){
        boolean b = lock.tryLock();
        System.out.println(b);
        if(b){
            try {
                workIng();
                System.out.println(Thread.currentThread().getName() +"上班中");
                workOff();
            }catch (Exception ex){
                ex.printStackTrace();
            }finally {
                if(lock != null){
                    lock.unlock();
                }
            }
        }else{
            System.out.println(Thread.currentThread().getName()+"无法上班，有人还未下班");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final LockExample  lockExample = new LockExample();
        List<Thread> threadList = new ArrayList<>(50);
        int i = 0 ;
        do {
            Thread a = new Thread(new Runnable() {
                @Override
                public void run() {
                    lockExample.work();
                }
            },"a_"+i);

            Thread b = new Thread(new Runnable() {
                @Override
                public void run() {
                    lockExample.work();
                }
            },"b_"+i);
            threadList.add(a);
            threadList.add(b);

        }while(i++ < 50);

        threadList.forEach(s->{
            s.start();
        });

        Thread.sleep(5000);
        System.out.println("main over!");
    }
}

为了效果展示，work方法 Thread.sleep(100);

效果如下 ：

总结下lock的使用：

a.先创建一个lock对象，Lock lock = new ReentrantLock()；

b.work方法进入，需要线程同步，开始先获取锁，若锁被其他线程占用，则阻塞

c.执行完work方法之后，unlock释放锁，释放锁和lock是成对出现的，确保unlock要在锁使用完之后及时释放，否则造成死锁；所以一般放在finally里面释放锁.

d.对比上面LockExample中的workTryLock使用的lock.tryLock();tryLock会尝试获取锁，方法有返回值；如果获取到锁，返回true；tryLock可以传等待时间，即在特定的时间内获取锁；

而lock.lock跟synchronzied一样，直接占用锁，无需返回值，其他线程进来若锁被占用，则会阻塞；

 

2.Lock和Condtion配合使用

有些场景都线程执行要顺序要求，即需要保证并发时入队和出队的要求，类似实现线程A的执行需要等待线程B执行完成才执行，

类似CountDownLatch的功能，但是它更多用于阻塞队列，生产者消费者的模式，实现等待通知机制；

我们模拟下并发线程中的有界队列

package com.lhy.jui.tools.lock;

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: lihuiyong
 * @DATE : 2019/10/31
 * @version:1.0.0
 * @description:   lock 和 condition结合实现线程安全中的有界队列
 */
public class LockWithCondition {


    public static class BlockQuene<T> {
        /**
         * 队列
         */
        private List quene = new LinkedList<T>();
        /**
         * 队列大小
         */
        private int queneLimit;
        /**
         * lock
         */
        private Lock lock = new ReentrantLock();
        /**
         * take操作
         */
        private Condition takeCondition = lock.newCondition();
        /**
         * put操作
         */
        private Condition putCondition = lock.newCondition();

        public BlockQuene(int queneLimit) {
            this.queneLimit = queneLimit;
        }

        /**
         * 入队
         */
        public void pushQuene(T t) {
            lock.lock();
            try {
                if (quene.size() == queneLimit) {
                    //队列已满，阻塞put操作
                    putCondition.await();
                }
                quene.add(t);
                takeCondition.signal();
            } catch (Exception ex) {
                ex.printStackTrace();
            } finally {
                if (lock != null) {
                    lock.unlock();
                }
            }
        }

        /**
         * 出队
         */
        public T popQuene() {
            lock.lock();
            T t = null;
            try {
                if (quene.isEmpty()) {
                    //队列为空，阻塞take操作
                    takeCondition.await();
                }
                putCondition.signal();
                t = (T)quene.remove(0);

            } catch (Exception ex) {
                ex.printStackTrace();
            } finally {
                if (lock != null) {
                    lock.unlock();
                }
            }
            return t;
        }
    }

    public static class ThreadPop implements Runnable{

        private BlockQuene<Integer> bolckQuene;

        public ThreadPop(BlockQuene<Integer> bolckQuene){
            this.bolckQuene = bolckQuene;
        }
        @Override
        public void run() {
            while(true){
                try {
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName()+" will pop.....");
                    Integer i = bolckQuene.popQuene();
                    System.out.println(" i="+i.intValue()+" alread pop");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    public static class ThreadPush implements Runnable{

        private BlockQuene<Integer> bolckQuene;

        public ThreadPush(BlockQuene<Integer> bolckQuene){
            this.bolckQuene = bolckQuene;
        }
        @Override
        public void run() {
           int i = 5;
           while (i> 0){
               try {
                   Thread.sleep(5000);
                   System.out.println(" i="+i+" will push");
                   bolckQuene.pushQuene(i--);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        }
    }


    public static void main(String[] args) {
        BlockQuene b = new BlockQuene(10);

        Thread threadPop = new Thread(new ThreadPop(b));
        Thread threadPush = new Thread(new ThreadPush(b));
        threadPush.start();
        threadPop.start();

    }

}

运行效果 :

Condition与Lock配套使用，通过 lock.newConditin() 进行实例化

BlockQuene 类主要两个方法，一个入列一个出列，takeCondition 和 putCondition分别用于出列和入列的阻塞；通过pushQuene和popQuene实现入出队列的操作；

当popQuene时，如果队列为空，则用takeCondition 阻塞线程，若队列不为空，则直接pop，同时通知putCondition可以push；

当pushQuene时，如果队列已满，则用putCondition阻塞线程，若队列未满，加入队列同时通知takeCondition 可以pop了；

掌握这个原理之后，我们再去了解下阻塞队列BlockingQueue就比较简单了，后续会介绍BlockingQueue。

 

 


 

 

扣弦为兰君
关注
专栏目录
Java并发编程系列06:Lock之ReentrantLock(1)
fen_fen的专栏
11-25 958
前提：在学Lock时，发现创建对象用的是ReentrantLock。这里也了解下“ReentrantLock” //创建一个锁对象 private final Lock lock = new ReentrantLock(); 上一篇文章：多线程学习04--＞解决多线程安全-Lock https://blog.csdn.net/fen_fen/article/details/121470551 ReentrantLock简介 ReentrantLock是一个可重入且独占式的锁，它具有与使用sy
java并发编程实战源码-concurrent-programming:《Java并发编程实战》源码整理
05-25
《Java并发编程实战》这本书是Java并发编程领域的一本经典之作，它深入浅出地讲解了如何在Java环境中高效、安全地进行多线程编程。源码整理集合`concurrent-programming-master`提供了书中示例代码，对于学习和理解...
浅谈ReentrantLock
xhh198781的专栏
12-16 1765
Condition只是一个接口，怎么可以直接调用它的方法呢？于是查源码（发现这个东西才是最彻底的），从ReentrantLock开始， ReentrantLock.newCondition() ->Sync.newCondition() Sync是一个静态抽象的内部类 ->ConditionObject 看来这个类最终实现了Condition接口 ->AbstractQueuedSynch
Java并发(二):Lock的使用-ReentrantLock类
小东东
05-24 223
现对《Java多线程编程核心技术》中讲述的ReentrantLock类的使用条目，作一下个人总结，内容如下： 一、ReentrantLock-可重入锁 1、实现同步： private Lock lock = new ReentrantLock(); public void runMethod() { lock.lock(); for...
JUC并发编程
最新发布
2301_76556912的博客
09-22 871
应用场景：1.多线程任务汇总。2.多线程任务阻塞住，等待发令枪响，一起执行。每次有线程调用，数量-1，当计数器归零，countDownLatch.await()就会被唤醒向下执行。// 总数是6，必须要是执行任务的时候使用i < 6;i++) {// 数量-1}).start();// 等待计数器归零，然后再往下执行System.out.println("关门");方式抛出异常有返回值，不抛出异常阻塞，一直等待阻塞，超时等待添加add()offer()put()
java concurrency_GitHub - CL0610/Java-concurrency: Java并发知识点总结
weixin_39820437的博客
02-15 119
努力的意义，就是，在以后的日子里，放眼望去全是自己喜欢的人和事！欢迎提issue和Pull request。所有的文档都是自己亲自码的，如果觉得不错，欢迎给star鼓励支持 :)整个系列文章为Java并发专题，一是自己的兴趣，二是，这部分在实际理解上很有难度，另外在面试过程中也是经常被问到。所以在学习过程中，记录了Java并发相关的基础知识，一是自己对知识能够建立体系，同时也希望有幸能够对其他人有...
Java并发编程之显示锁ReentrantLock和ReadWriteLock读写锁
09-03
Java并发编程中的显示锁，即ReentrantLock，是Java 5.0引入的重要特性，它为多线程环境提供了更为灵活的控制。ReentrantLock是一个可重入的锁，这意味着一个线程可以多次获取同一锁，这与synchronized内置锁的行为...
浅谈Java并发编程之Lock锁和条件变量
08-18
"浅谈Java并发编程之Lock锁和条件变量" Lock锁是Java并发编程中的一种重要机制，它提供了比synchronized更加广泛的锁定操作。Lock接口有三种实现类：ReentrantLock、ReetrantReadWriteLock.ReadLock和...
深入java并发编程，使用ReentrantLock和 Synchronized加锁
12-25
在Java并发编程中，理解和熟练使用同步机制是至关重要的，这包括了`ReentrantLock`和`synchronized`关键字。这两个工具都是为了确保多线程环境中的数据一致性与安全性，防止出现竞态条件和死锁等问题。 `...
线程安全的部分知识
tyf4350158的博客
04-25 316
package cn.tan.phenomenon; public class Main { // 定义一个共享的数据 —— 静态属性的方式来体现 static int r = 0; // 定义加减的次数 // COUNT 越大，出错的概率越大；COUNT 越小，出错的概率越小 static final int COUNT = 1000_000_00; // 定义两个线程，分别对 r 进行 加法 + 减法操作 static class Add .
java 阻塞控制
weixin_42660202的博客
01-08 532
1.单项阻塞 block方法直接阻塞当前代码,等待其他线程执行release方法后,阻塞代码直接释放 测试代码: /** * 阻塞释放与锁对象 */ public class BlockLock { public BlockLock() { } public void block() { synchronized (this) {//阻塞代码 try { this.wait(); .
java培训：多个线程同时访问一个类是否有问题
weixin_45695430的博客
03-04 1158
一.synchronized 1.多个线程同时访问同一个类实例对象的两个同步方法： package synchronizedTest; public class Example1 { private int num = 0 ; (省略getter.setter，后同) public synchronized void method1() { System.out.println("同步方法1进入"); for(int i = 0 ; i<10 ; i++) { System.out.
【多线程】Lock和ReentrantLock使用和源码分析
weixin_44823875的博客
03-24 1513
多线程---Lock和ReentrantLock使用详情（1）Lock和ReentrantLock介绍（2）Lock锁实现同步效果（3）Lock的trylock方法（4）使用Lock时候的线程交互（5）总结Lock（ReentrantLock）和synchronized的区别（6）ReenTrantLock实现的原理（7）什么情况下使用ReenTrantLock（8）案例一：使用Lock把MyStack改造为线程安全的类并且实现生产者消费者问题（9）案例二：借助tryLock 解决死锁问题 （1）Lock和
Java并发学习之ReentrantLock的工作原理及使用姿势
小灰灰blog的专栏
11-11 542
Lock,ReentrantLock的工作原理及使用方式jdk提供synchronized实现线程同步，但有些场景下并不灵活，如多个同步方法，每次只能有一个线程访问；而Lock则可以非常...
AQS-ReentrantLock入队出队源码解析
岁月
03-29 406
下面是个人的理解与查看源码的备注，如果有不正确的地方，请评论指出。万分感谢 lock是可重入、 可公平与非公平的 、可共享与独占的 如何证明？请看下列测试代码 public class ReentrantLockTest { private static int sum = 0; private static Lock lock = new ReentrantLock(); public static void main(String[] args) { fo
ArrayBlockingQueue
农夫三拳
03-06 320
使用提示：ArrayBlockingQueue结合线程池一起使用实现并行业务处理的需求非常高效，ArrayBlockingQueue#take取出的对象用作null表示等待处理。（FIFO）的原则，它是一个基于。基础数据结构Object[]
Java多线程-新特征-锁(上)
weixin_34281477的博客
07-25 195
在Java5中，专门提供了锁对象，利用锁可以方便的实现资源的封锁，用来控制对竞争资源并发访问的控制，这些内容主要集中在java.util.concurrent.locks 包下面，里面有三个重要的接口Condition、Lock、ReadWriteLock。 Condition: Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对...
Java并发编程：深入理解ReentrantLock
在Java并发编程中，ReentrantLock（重入锁）是一个重要的工具，它实现了Lock接口，并且在实际应用中被广泛使用。ReentrantLock的主要特点就是支持重入性和可选择的公平性或非公平性。 一、ReentrantLock的重入性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值