Lock对象的使用

已于 2022-03-17 13:16:40 修改
阅读量288 收藏
点赞数
分类专栏： Java多线程 文章标签： java 开发语言 后端
于 2022-01-17 12:34:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Voctorial/article/details/122231214
版权

使用Lock对象实现同步效果，Lock对象在功能上比synchronized 更加丰富，着重要掌握 ReentrantLock 类和 ReentrantReadWriteLock 类的使用

文章目录

ReentrantLock 类

使用ReentrantLock 实现同步

调用ReentrantLock 对象的lock方法获取锁，调用unlock 方法释放锁，这两个方法成对使用，要想实现代码同步只需把代码放在lock和unlock之间即可

package P299;

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

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

    public void testMethod(){
        lock.lock();
        for (int i = 0; i < 5; i++) {
            System.out.println("ThreadName="+Thread.currentThread().getName()+(" "+(i+1)));
        }
        lock.unlock();
    }
}

package P299;

public class MyThread extends Thread {
    private MyService myService;

    public MyThread(MyService myService){
        this.myService=myService;
    }

    @Override
    public void run() {
        myService.testMethod();
    }
}

package P299;

public class Test {
    public static void main(String[] args) {
        MyService myService = new MyService();
        MyThread myThread1 = new MyThread(myService);
        MyThread myThread2 = new MyThread(myService);
        MyThread myThread3 = new MyThread(myService);

        myThread1.start();
        myThread2.start();
        myThread3.start();

    }
}

在这里插入图片描述

await 方法的使用

package P307;

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

public class MyService {
    private ReentrantLock lock=new ReentrantLock();
    private Condition condition=lock.newCondition();

    public void waitMethod(){
        try{
            lock.lock();
            System.out.println("A");
            condition.await();
            System.out.println("B");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
            System.out.println("锁被释放了");
        }
    }
}

package P307;

public class MyThreadA extends Thread {
    private MyService myService;
    public MyThreadA(MyService myService){
        this.myService=myService;
    }

    @Override
    public void run() {
        myService.waitMethod();
    }
}

在这里插入图片描述

await signal 实现等待通知机制

package P308;

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

public class MyService {
    private ReentrantLock lock=new ReentrantLock();
    private Condition condition=lock.newCondition();

    public void await(){
        try {
            lock.lock();
            System.out.println("await 时间为"+System.currentTimeMillis());
            condition.await();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }

    public void signal(){
        try {
            lock.lock();
            System.out.println("signal时间为"+System.currentTimeMillis());
            condition.signal();
        }finally {
            lock.unlock();
        }
    }

}

package P308;


import java.net.ServerSocket;

public class ThreadA extends Thread {
    private MyService myService=new MyService();
    public ThreadA(MyService myService){
        this.myService=myService;
    }

    @Override
    public void run() {
        myService.await();
    }
}

package P308;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();
        ThreadA threadA = new ThreadA(myService);
        threadA.start();
        Thread.sleep(3000);
        myService.signal();
    }
}

在这里插入图片描述

通知全部线程

package P312;

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

public class MyService {
    private Lock lock=new ReentrantLock();
    private Condition condition=lock.newCondition();

    public void awaitA(){
        try {
            lock.lock();
            System.out.println("begin awaitA时间为"+System.currentTimeMillis()+"  ThreadName="+Thread.currentThread().getName());
            condition.await();
            System.out.println("end awaitA时间为"+System.currentTimeMillis()+"  ThreadName="+Thread.currentThread().getName());
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }

    public void awaitB(){
        try {
            lock.lock();
            System.out.println("begin awaitB时间为"+System.currentTimeMillis()+"  ThreadName="+Thread.currentThread().getName());
            condition.await();
            System.out.println("end awaitB时间为"+System.currentTimeMillis()+"  ThreadName="+Thread.currentThread().getName());
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void signalAll(){
        try {
            lock.lock();
            System.out.println("signalAll时间为"+System.currentTimeMillis()+"  ThreadName="+Thread.currentThread().getName());
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }
}

在这里插入图片描述

通知部分线程

package P315;

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

public class MyService {
    private Lock lock=new ReentrantLock();
    public Condition conditionA=lock.newCondition();
    public Condition conditionB=lock.newCondition();

    public void awaitA(){
        try {
            lock.lock();
            System.out.println("begin awaitA time="+System.currentTimeMillis()+"  ThreadName="+ Thread.currentThread().getName());
            conditionA.await();
            System.out.println("end awaitA time="+System.currentTimeMillis()+"  ThreadName="+ Thread.currentThread().getName());
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void awaitB(){
        try {
            lock.lock();
            System.out.println("begin awaitB time="+System.currentTimeMillis()+"  ThreadName="+ Thread.currentThread().getName());
            conditionB.await();
            System.out.println("end awaitB time="+System.currentTimeMillis()+"  ThreadName="+ Thread.currentThread().getName());
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void signalA(){
        try {
            lock.lock();
            System.out.println("signalA time="+System.currentTimeMillis()+"  ThreadName="+ Thread.currentThread().getName());
            conditionA.signalAll();
        }finally {
            lock.unlock();
        }
    }

    public void signalB(){
        try {
            lock.lock();
            System.out.println("signalB time="+System.currentTimeMillis()+"  ThreadName="+ Thread.currentThread().getName());
        }finally {
            lock.unlock();
        }
    }
}

package P315;


public class ThreadA extends Thread {
    private MyService myService;
    public ThreadA(MyService myService){
        this.myService=myService;
    }

    @Override
    public void run() {
        myService.awaitA();
    }
}

package P315;

public class ThreadB extends Thread {
    private MyService myService;
    public ThreadB(MyService myService){
        this.myService=myService;
    }

    @Override
    public void run() {
        myService.awaitB();
    }
}

package P315;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();
        ThreadA threadA = new ThreadA(myService);
        ThreadB threadB = new ThreadB(myService);
        threadA.start();
        threadB.start();
        Thread.sleep(3000);
        myService.signalA();
    }
}

在这里插入图片描述

生产者、消费者一对一交替输出

package P317;

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

public class MyService {
    private ReentrantLock lock=new ReentrantLock();
    private Condition condition=lock.newCondition();
    private boolean hasValue=false;
    public void set(){
        try {
            lock.lock();
            if(hasValue==true){
                condition.await();
            }
            System.out.println("A");
            hasValue=true;
            condition.signal();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void get(){
        try {
            lock.lock();
            if(hasValue==false){
                condition.await();
            }
            System.out.println("B");
            hasValue=false;
            condition.signal();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

package P317;

public class MyThreadA extends Thread {
    private MyService myService;
    public MyThreadA(MyService myService){
        this.myService=myService;
    }

    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            myService.set();
        }
    }
}

package P317;


public class MyThreadB extends Thread {
    private MyService myService;
    public MyThreadB(MyService myService){
        this.myService= myService;
    }

    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            myService.get();
        }
    }
}

package P317;

public class Run {
    public static void main(String[] args) {
        MyService myService = new MyService();
        MyThreadA myThreadA = new MyThreadA(myService);
        MyThreadB myThreadB = new MyThreadB(myService);

        myThreadA.start();
        myThreadB.start();
    }
}

在这里插入图片描述

生产者、消费则多对多交替输出

package P317;

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

public class MyService {
    private ReentrantLock lock=new ReentrantLock();
    private Condition condition=lock.newCondition();
    private boolean hasValue=false;
    public void set(){
        try {
            lock.lock();
            while (hasValue==true){
                condition.await();
            }
            System.out.println("A"+"----"+Thread.currentThread().getName());
            Thread.sleep(100);
            hasValue=true;
            condition.signalAll();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void get(){
        try {
            lock.lock();
            while (hasValue==false){
                condition.await();
            }
            System.out.println("B"+"----"+Thread.currentThread().getName());
            Thread.sleep(100);
            hasValue=false;
            condition.signalAll();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

package P317;

public class MyThreadA extends Thread {
    private MyService myService;
    public MyThreadA(MyService myService){
        this.myService=myService;
    }

    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            myService.set();
        }
    }
}

package P317;


public class MyThreadB extends Thread {
    private MyService myService;
    public MyThreadB(MyService myService){
        this.myService= myService;
    }

    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            myService.get();
        }
    }
}

package P317;

public class Run {
    public static void main(String[] args) {
        MyService myService = new MyService();
        for (int i = 0; i < 5; i++) {
            MyThreadA myThreadA = new MyThreadA(myService);
            MyThreadB myThreadB = new MyThreadB(myService);
            myThreadA.start();
            myThreadB.start();
        }
    }
}

在这里插入图片描述
注意：使用signal 可能会出现假死，使用signalAll则可以避免；while

公平锁和非公平锁

公平锁：采用先到先得的策略，每次获取锁之前会检查队列里有没有排队等待的线程，没有才会去获取锁，否则就将当前线程追加到队列中

package P323;

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

public class MyService {
    public Lock lock;
    public MyService(boolean fair){
        lock=new ReentrantLock(fair);
    }
    public void testMethod(){
        try {
            lock.lock();
            System.out.println("testMethod "+Thread.currentThread().getName());
            Thread.sleep(500);
            lock.unlock();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

package P323;

public class MyThread extends Thread {
    private MyService myService;
    public MyThread(MyService myService){
        this.myService=myService;
    }

    @Override
    public void run() {
        myService.testMethod();
    }
}

package P323;

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService(true);
        MyThread[] myThreads = new MyThread[10];
        MyThread[] myThreads1 = new MyThread[10];
        for (int i = 0; i < myThreads.length; i++) {
            myThreads[i]=new MyThread(myService);
            myThreads[i].setName("A++++"+(i+1));
        }
        for (int i = 0; i <myThreads.length; i++) {
            myThreads[i].start();
        }
        for (int i = 0; i < myThreads1.length; i++) {
            myThreads1[i]=new MyThread(myService);
            myThreads1[i].setName("B++++"+(i+1));
        }
        Thread.sleep(500);
        for (int i = 0; i < myThreads1.length; i++) {
            myThreads1[i].start();
        }
    }
}

在这里插入图片描述
非公平锁：采用“有机会插队”的策略，一个线程获取锁之前要先去尝试获取锁而不是在队列中等待，如果锁获取成功，则说明虽然线程是后启动的，但是先获取了锁。如果没有获取锁成功，那么才将自身追加到队列中等待
多次运行可能出现后启动的线程先抢到锁

常见方法

public int getHoldCount()

当前线程保持锁的个数，即调用lock方法的次数

public final int getQueueLength()

返回正等待获取此锁的线程估计数

使用ReentrantReadWriteLock类

ReentrantLock类具有完全互斥排他的效果，同一时间只有一个线程执行ReentrantLock.lock()方法后面的任务，这样做虽然保证了同时写实例变量的线程安全性，但是效率非常低下。
使用ReentrantReadWriteLock类可以进行读操作时不需要同步执行，提升速度，加快效率
读相关的锁也称为共享锁，写相关的锁也成为排它锁
读锁之间不互斥，读锁和写锁互斥，写锁和写锁也互斥

RainHey
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ReentrantLock源码详解--条件锁
08-25
主要介绍了ReentrantLock源码之条件锁，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，下面我们来一起学习一下吧
Lock对象
PC_small_wang的博客
08-16 410
Lock锁对象 1、创建锁对象 Lock l = new ReentrantLock; 2、Lock锁对象释放锁需要手动释放，遇到异常也不会自动释放。所以一般会放在finally之中。 3、示例 Lock lock = new ReentrantLock; m(){ lock.lock(); ....... finally{ lock.unlock(); } } 4、tryLock尝试锁 tryLock是尝试进行锁，不管锁定与否，方法都将继续执行。 boolean locked = fals
使用显示的lock对象
tomorrow_fine的博客
05-01 461
lock()方法加锁，unlock()方法释放锁。 tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。 tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，
同步问题的解决--锁对象Lock
ChineseSoftware的博客
06-30 322
Synchronized和lock区别 一、java.util.concurrent.locks Lock 是java.util.concurrent.locks包下的接口，Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作，它能以更优雅的方式处理线程同步问题。代码如下： public class LockTest { public static void main(String[] args) { final Outputter op = new
使用synchronized和Lock对象获取对象锁
阿O、不拽
09-16 176
 Java:使用synchronized和Lock对象获取对象锁     下面使用ReentrantLock这个锁来实现加锁功能：     package com.tch.test.concurrent; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; ...
C#中Monitor对象与Lock关键字的区别分析
09-05
主要介绍了C#中Monitor对象与Lock关键字的区别，需要的朋友可以参考下
JAVA Lock加锁实例
07-10
Lock锁是对象锁，仅在同一对象中，锁才会生效。（不做论证） （以下场景皆为单例模式下运行） lock.lock()的加锁方式，会使后续请求的线程堵塞等待。（方案A） lock.tryLock()的加锁方式，不会堵塞，会立即返回加锁...
lock锁，lock锁和synchronized的对比
11-19
一种显式定义同步锁对象来实现锁，提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock锁。 # synchronized锁与lock锁的对比 Lock是显式锁，需要手动的开启和...
C#中lock用法详解
01-20
lock 语句用于获取某个给定对象的互斥锁，执行一个语句，然后释放该锁。 lock-statement:(lock 语句：) 代码如下:lock(expression) embedded-statement(lock ( 表达式 ) 嵌入语句) lock 语句的表达式必须表示...
4.锁Lock对象
qq_28870649的博客
02-01 352
锁Lock对象     Lock在jdk1.8前性能比synchronize好，     Lock比synchronize代码灵活，用法多          用synchronized时，多线程写作工作需要用wait、notify、notifyAll进行配合工作          用Lock时，用Condition进行线程间的协作，Condition针对具体某一把锁而不是类。只有在
Lock和Condition对象的使用
tomorrow_fine的博客
05-27 376
Condition的await()方法 void await() throws InterruptedException 导致当前线程等到发信号或interrupted 。 与此相关的锁Condition以原子方式释放，并且当前线程的线程调度目的就退出，一直处于休眠状态的四两件事发生对象 ： 一些其它线程调用signal()方法本Condition和当前线程碰巧被选择作
[多线程] - Lock对象的使用详解
xiaoai1994的博客
12-11 1136
文章目录一、Lock对象简介二、Lock对象的应用1.Lock对象的同步性验证1）Lock接口的实现类2）Lock对象实现同步3）多代码块之间的同步性4）unlock的使用2. Condition与多路通知1）condition实现wait/notify通知模型2）选择性通知3）Condition对象的总结4） Condition对象的面试题三、Lock对象的锁特性1.公平锁与非公平锁2.读写锁（共享锁与排它锁） 一、Lock对象简介 按照惯例，我们在介绍一个对象前首先要翻译一下他的语义： 什么，锁？是不
java多线程-Lock对象的使用
weixin_51343683的博客
09-09 223
作用是查询是否有线程正在等待与此锁有关的condition条件，也就是是否有线程执行了condition对象中的await()方法而呈等待状态。作用是嗅探拿锁，如果当前线程发现锁被其他线程持有了，则返回false，程序继续执行后面的代码，而不是呈阻塞等待锁的状态。作用是查询指定的线程是否正在等待获取此锁，也就是判断参数中的线程是否在等待队列中。作用是查询是否有线程正在等待获取此锁，也就是等待队列中是否有等待的线程。作用是查询“当前线程“保持此锁定的个数，即调用lock()方法的次数。
Java线程(八)：锁对象Lock-同步问题更完美的处理方式
热门推荐
寻道
04-14 11万+
Lock是java.util.concurrent.locks包下的接口，Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作，它能以更优雅的方式处理线程同步问题，我们拿Java线程(二)中的一个例子简单的实现一下和sychronized一样的效果，代码如下： public class LockTest { public static voi...
多线程学习笔记（六）之锁对象Lock
Megustas_JJC的博客
05-05 982
接口Lock首先我们回顾下同步代码块，例如：Object obj = new Object(); void show(){ synchronized(obj){ code... } }同步代码块对锁的操作是隐式的，执行完同步代码块中的内容，自动释放锁。而Lock将锁封装成为了对象，即把对锁操作的隐式操作换成了显示操作。可以将如上代码改写：Lock lock = new
Java 中的Lock锁对象(ReentrantLock/ReentrantReadWriteLock)详解
swadian2008的博客
08-29 2982
当有线程获取读锁时，如果当前没有线程持有写锁，则读锁将立即被获取，读锁计数器加一，表示当前有一个线程持有读锁。在 getValue() 方法中，线程会获取锁，返回共享变量 value 的值，最后释放锁。例如，如果一个线程在尝试获取锁的过程中遇到了饥饿现象（即一直获取不到锁），那么系统可能会采用类似于睡眠的方式，让该线程暂时让出 CPU 资源，等待一段时间后再次尝试获取锁。接着，它获取读锁，释放写锁，这样就实现了锁降级。这是因为写锁是独占锁，不能被多个线程同时持有，而读锁是共享锁，可以被多个线程同时持有。
Java Lock对象
假装你是大灰狼的专栏
12-03 3212
1. ReentrantLock类 ReentrantLock可以实现线程之间同步互斥，类似于synchronized同样的效果。 public class ThreadReentrantLock { public static void main(String[] args) { ThreadA threadA = new ThreadA(); for...
java的reentrantlock_Java并发编程锁系列之ReentrantLock对象总结
weixin_30036893的博客
02-12 120
Java并发编程锁系列之ReentrantLock对象总结在Java并发编程中，根据不同维度来区分锁的话，锁可以分为十五种。ReentranckLock就是其中的多个分类。本文主要内容：重入锁理解;重入锁代码演示; ReentranckLock的总结本篇是《凯哥(凯哥Java:kagejava)并发编程学习》系列之《Lock系列》教程的第四篇：《Java并发包下锁学习第六篇：ReentranckL...
【Java并发编程】Lock锁对象
p0pp0p0的专栏
07-30 1486
前面我们一直提到的，同步代码（synchronized方法，synchronized变量）依赖于可重入锁，这种锁很容易使用，但是有很多局限性。更复杂的锁在Java.util.concurrent.locks包中，我们今天只简单聊聊Lock对象。Lock对象工作方式很想我们前面提到的同步锁，我们将前面介绍过的锁称作隐示锁。和隐示锁一样，Lock对象一次也只能只能有一个对象拥有该锁。Lock对象也可以通
WakeLock使用
最新发布
08-23
1. 使用PowerManager类：可以通过PowerManager类来获取WakeLock对象，并使用acquire()和release()方法来控制设备的唤醒状态。这种方式需要申请WAKE_LOCK权限。 2. 在Window设置flag：可以使用WindowManager....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值