Lock对象的使用

最新推荐文章于 2021-02-21 07:09:39 发布
最新推荐文章于 2021-02-21 07:09:39 发布
阅读量2.3k 收藏 1
点赞数
分类专栏： java多线程 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BBBgreat/article/details/107015921
版权

Lock对象在功能上比sybchronized更加丰富。

ReentrantLock类

使用ReentrantLock实现同步
调用ReentrantLock对象的lock()获取锁，调用unlock()释放锁，如下

lock的使用

public class MyService {

    private Lock lock = new ReentrantLock();

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

}

线程类

public class MyThread extends Thread {

    private MyService myService;

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

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

}

测试

public class Test {

    public static void main(String[] args) {
        MyService myService = new MyService();

        MyThread a = new MyThread(myService);
        MyThread b = new MyThread(myService);
        MyThread c = new MyThread(myService);

        a.start();
        b.start();
        c.start();
    }
}

结果
在这里插入图片描述
可以看出，只有当锁释放后，其他线程才可以继续抢锁并输出（抢锁顺序与启动的顺序不一定一致）

Condition对象的使用
Condition对象具有更好的灵活性。例如，可以实现多路通知功能，也就是在一个Lock对象中可以创建多个Condition实例，线程对象注册在指定的Condition中，从而可以有选择性的进行线程的通知，在调度上更加灵活

在使用notify()/notifyAll()方法进行通知时，被通知的线程由JVM选择，而notifyAll()会通知所有waiting线程，没有选择权。

Condition对象的作用是控制并处理线程状态，它可以使线程保持wait状态，也可以让其继续运行，如下

创建Lock对象和Condition对象

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("锁释放了");
        }
    }

}

线程类

public class MyThread extends Thread {

    private MyService myService;

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

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

}

测试

public class Test {

    public static void main(String[] args) {
        MyService myService = new MyService();
        MyThread a = new MyThread(myService);
        MyThread b = new MyThread(myService);
        MyThread c = new MyThread(myService);

        a.start();
        b.start();
        c.start();
    }

}

结果
在这里插入图片描述
说明调用Condition对象的await()方法将当前执行任务的线程转换成wait状态，并释放锁

使用Condition对象的方法实现wait/notify机制
Condition对象拥有await()和signal()，和wait()、notify()效果类似，如下
业务代码

public class MyService {

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

    public void await() {
        try {
            lock.lock();
            System.out.println("await's time is " + System.currentTimeMillis());
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void signal() {
        try {
            lock.lock();
            System.out.println("signal's time is " + System.currentTimeMillis());
            condition.signal();
        } finally {
            lock.unlock();
        }
    }

}

线程类

public class MyThread extends Thread {

    private MyService myService;

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

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

}

测试

public class Test {

    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();

        MyThread myThread = new MyThread(myService);
        myThread.start();
        Thread.sleep(3000);

        myService.signal();
    }
}

结果
在这里插入图片描述

await()运行原理： 并发包源代码内部执行了Unsafe类中的public native void park(boolean isAbsolute, long time)方法，让当前线程暂停。isAbsolute代表是否为绝对时间，time代表时间值

通知部分线程
可以通过Condition对象唤醒部分指定的线程（有助于提高效率），也可以对线程分组，然后唤醒指定组中的线程

业务代码

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 await A time is" + System.currentTimeMillis() +
                    "ThreadName is " + Thread.currentThread().getName());
            conditionA.await();
            System.out.println("end await A time is" + System.currentTimeMillis() +
                    "ThreadName is " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

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

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

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

}

线程类A， B

public class ThreadA extends Thread {

    private MyService myService;

    public ThreadA(MyService myService) {
        super();
        this.myService = myService;
    }

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

}

public class ThreadB extends Thread {

    private MyService myService;

    public ThreadB(MyService myService) {
        super();
        this.myService = myService;
    }

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

}

测试

public class Test {

    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();

        ThreadA a = new ThreadA(myService);
        a.setName("A");
        a.start();
        ThreadB b = new ThreadB(myService);
        b.setName("B");
        b.start();

        Thread.sleep(3000);

        myService.signalAll_A();
    }
}

结果
在这里插入图片描述
A被唤醒，B还继续等待

公平锁与非公平锁
公平锁：采用先到先得的策略，每次获取锁之前都会检查队列里面有没有排队等待的线程，没有才会尝试获取锁，有就追加到队列中。
非公平锁：采用“有机会插队”的策略，一个线程获取锁之前要先去尝试获取锁而非在队列等待，即后启动也可能先拿到锁。如果没有拿到，那么才将自身追加到队列中进行等待。

ReentrantReadWriteLock类

ReentrantLock类具有完全排他的效果，同一时间只有一个线程在执行lock.lock()后的任务，效率低下
ReentrantReadWriteLock进行读操作的时候不需要同步，提升运行速度。
读写有两个锁：一个读相关–共享锁，一个写相关–排它锁
读锁间不互斥，其他均互斥

以下各部分只有业务代码不同，线程类，测试类一致
先给出线程类、测试类

public class MyThread extends Thread {
    
    private MyService myService;

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

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

public class Test {

    public static void main(String[] args) {
        MyService myService = new MyService();
        MyThread a = new MyThread(myService);
        a.start();
        MyThread b = new MyThread(myService);
        b.start();
    }
    
}

读读共享

public class MyService {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private String username = "abc";

    public void testMethod() {
        try {
            lock.readLock().lock();
            System.out.println("begin " + Thread.currentThread().getName() + "  " +
                    System.currentTimeMillis());
            System.out.println("print service " + username);
            Thread.sleep(4000);
            System.out.println("    end " + Thread.currentThread().getName() + " " +
                    System.currentTimeMillis());
            lock.readLock().unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
}

结果
在这里插入图片描述

写写互斥

public class MyService {
    
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
    public void write() {
        try {
            try {
                lock.writeLock().lock();
                System.out.println("get writeLock " + Thread.currentThread().getName() + " " + 
                        System.currentTimeMillis());
                Thread.sleep(10000);
            } finally {
                lock.writeLock().unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
}

结果
在这里插入图片描述
注意时间差（互斥）

读写互斥
此处各部分代码与上述均不同

业务代码

public class MyService {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
    public void read() {
        try {
            try {
                lock.readLock().lock();
                System.out.println("get readLock " + Thread.currentThread().getName() + "  " + 
                        System.currentTimeMillis());
                Thread.sleep(10000);
            } finally {
                lock.readLock().unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public void write() {
        try {
            try {
                lock.writeLock().lock();
                System.out.println("get writeLock " + Thread.currentThread().getName() + "  " + 
                        System.currentTimeMillis());
                Thread.sleep(10000);
            } finally {
                lock.writeLock().unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程类

public class MyThread extends Thread {

    private MyService myService;

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

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

}

public class MyThreadB extends Thread {

    private MyService myService;

    public MyThreadB(MyService myService) {
        super();
        this.myService = myService;
    }

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

测试方法：

public class Test2 {

    public static void main(String[] args) {
        MyService myService = new MyService();

        MyThread a = new MyThread(myService);
        a.setName("A");
        a.start();
        MyThreadB b = new MyThreadB(myService);
        b.setName("B");
        b.start();
    }
    
}

结果
在这里插入图片描述
注意时间差

写读互斥与上面读写互斥类似

BBBgreat
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#中Monitor对象与Lock关键字的区别分析
09-05
主要介绍了C#中Monitor对象与Lock关键字的区别，需要的朋友可以参考下
JAVA Lock加锁实例
07-10
Lock锁是对象锁，仅在同一对象中，锁才会生效。（不做论证） （以下场景皆为单例模式下运行） lock.lock()的加锁方式，会使后续请求的线程堵塞等待。（方案A） lock.tryLock()的加锁方式，不会堵塞，会立即返回加锁...
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检查
weixin_30258901的博客
12-15 75
---desc:oracle检查某个表对象上的lock SELECT username, schemaname, se.MACHINE, se.MODULE, 'ALTER SYSTEM KILL SESSION ' || '''' || se.sid || ',' || se.serial# || ',' || '@' || se.i...
从对象头的两个字宽解析对象的4种状态，锁信息，分代信息 和分析锁升级的过程
weixin_42765975的博客
02-12 364
什么是元数据： 解析数据的数据叫元数据，Java里面有4种类型的元数据，类，接口，枚举，注解，对象的元数据，就是处于方法区的类型对象信息 什么是CAS指令： CAS （Compare And Swap） 指令是一个CPU层级的原子性操作指令， Lock接口底层实现不是通过synchronized实现的 lock的实现完全是由java写的，和操作系统或者是JVM虚拟机没有任何关系。整体来看Lock主...
lock语句
天外有天，人外有人。 专注品质 不断创新 让精益求精成为习惯
01-13 692
<br />  用lock语句定义的对象表示，要等待指定对象的锁定解除。<br />只能传送引用类型。<br />锁定值类型只是锁定了一个副本，这是没有什么意义的。编译器会提供一个锁定值类型的错误。<br />    进行了锁定后—只有一个线程得到了锁定块，就可以运行lock语句块。在lock语句块的最后，对象的锁定被解除，另一个等待锁定的线程就可以获得该锁定块了。
lock锁，lock锁和synchronized的对比
11-19
一种显式定义同步锁对象来实现锁，提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock锁。 # synchronized锁与lock锁的对比 Lock是显式锁，需要手动的开启和...
C#中lock用法详解
01-20
lock 语句用于获取某个给定对象的互斥锁，执行一个语句，然后释放该锁。 lock-statement:(lock 语句：) 代码如下:lock(expression) embedded-statement(lock ( 表达式 ) 嵌入语句) lock 语句的表达式必须表示...
[多线程] - Lock对象的使用详解
xiaoai1994的博客
12-11 1143
文章目录一、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对象
假装你是大灰狼的专栏
12-03 3214
1. ReentrantLock类 ReentrantLock可以实现线程之间同步互斥，类似于synchronized同样的效果。 public class ThreadReentrantLock { public static void main(String[] args) { ThreadA threadA = new ThreadA(); for...
java lock 对象_Java™ 教程（Lock对象）
weixin_36293680的博客
02-16 278
Lock对象同步代码依赖于简单的可重入锁，这种锁易于使用，但有许多限制，java.util.concurrent.locks包支持更复杂的锁定语法，我们不会详细检查这个包，而是将重点放在其最基本的接口Lock上。Lock对象的工作方式与同步代码使用的隐式锁定非常相似，与隐式锁一样，一次只有一个线程可以拥有一个Lock对象，Lock对象还通过其关联的Condition对象支持wait/notify机...
正确使用lock 关键字
weixin_33716557的博客
06-13 72
lock关键字可以用来确保代码块完成运行，而不会被其他线程中断。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。 我们一般都这样使用lock 关键字 private static object syncObj =new object(); public static void DoTest(){ lock(syncObj){ ...
java 对象 lock_实现自己的Lock对象
weixin_31582915的博客
02-21 306
一直想好好学习concurrent包中的各个类的实现，然而经常看了一点就因为其他事情干扰而放下了。发现这样太不利于自己的成长了，因而最近打算潜心一件一件的完成自己想学习的东西。对concurrent包的学习打算先从Lock的实现开始，因而自然而然的就端起了AbstractQueuedSynchronizer，然而要读懂这个类的源码并不是那么容易，因而我就开始问自己一个问题：如果自己要去实现这个一个...
Java多线程Lock对象常用方法(3)
Lucy_Leezhi
02-27 2111
下面练习一下如下几个方法： isHeldByCurrentThread():查询当前线程是否保持此锁定 isFair():判断Lock是否为公平锁 isLocked():查询lock 是否被任意线程所持有。package com.lenovo.plm.dms.p23;import java.util.concurrent.locks.ReentrantLock;public class Ser
lock语句和线程安全
MSP_甄心cherish的专栏
01-03 2642
--------------以下部分内容摘自《C#高级编程(第八版)》--------------- 先来看一个简单的Demo： 首先是两个类的定义 Student类，只有一个简单的Num属性 public class Student { public int Num { get; set; } }Handler类 public class Handler {
4.锁Lock对象
qq_28870649的博客
02-01 352
锁Lock对象     Lock在jdk1.8前性能比synchronize好，     Lock比synchronize代码灵活，用法多          用synchronized时，多线程写作工作需要用wait、notify、notifyAll进行配合工作          用Lock时，用Condition进行线程间的协作，Condition针对具体某一把锁而不是类。只有在
对象头的锁类型状态介绍
qq_43147646的博客
08-28 758
对象头的锁类型 简单介绍一下各部分的含义 lock: 锁状态标记位，该标记的值不同，整个mark word表示的含义不同。 biased_lock：偏向锁标记，为1时表示对象启用偏向锁，为0时表示对象没有偏向锁。 1，age：Java GC标记位对象年龄。 2，identity_hashcode：对象标识Hash码，采用延迟加载技术。当对象使用HashCode()计算后，并会将结果写到该对象...
Java进阶学习笔记（八） 多线程编程（五）LOCK对象
TUTsmile的博客
07-23 119
文章目录LOCK对象1、 使用Lock实现同步效果2、tryLock3、线程交互4、总结Lock和synchronized的区别 LOCK对象 1、 使用Lock实现同步效果 示例 Lock是一个接口，为了使用一个Lock对象，需要用到new Lock lock = new ReentrantLock(); 与 synchronized (someObject) 类似的，lock()方法，表示当前线程占用lock对象，一旦占用，其他线程就不能占用了。 与 synchronized 不同的是，一旦synch
WakeLock使用
最新发布
08-23
WakeLock是Android中的一个机制，用于控制设备的唤醒状态。通过使用WakeLock，应用程序可以防止设备进入休眠状态，从而保持屏幕常亮。 在Android中，有几种方式可以使用WakeLock。其中包括以下几种常用方法： 1. 使用PowerManager类：可以通过PowerManager类来获取WakeLock对象，并使用acquire()和release()方法来控制设备的唤醒状态。这种方式需要申请WAKE_LOCK权限。 2. 在Window设置flag：可以使用WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON标志来设置窗口的保持唤醒状态。这种方式不需要申请权限，并且可以通过在Window的布局xml文件中的顶层布局添加android:keepScreenOn="true"属性来达到相同的效果。 3. 使用WakefulBroadcastReceiver：这是一种特殊的广播接收器，可以使用它来获取WakeLock对象，并在接收到广播时启用唤醒状态。这种方式适用于特定的场景，例如在接收到特定的广播消息时保持设备唤醒状态。 根据具体的需求和使用场景，可以选择适合的WakeLock使用方法。以上是其中几种常见的方法，可以根据需要选择合适的方式来控制设备的唤醒状态。<span class="em">1</span><span class="em">2</span> #### 引用[.reference_title] - *1* *2* [WakeLock的使用](https://blog.csdn.net/zmm911zmm/article/details/103134442)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值