java lock_java 中Lock的使用【转】

最新推荐文章于 2024-03-11 16:53:19 发布
最新推荐文章于 2024-03-11 16:53:19 发布
阅读量74 收藏
点赞数
文章标签： java lock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42510407/article/details/114029352
版权
本文详细介绍了ReentrantLock在多线程环境下的原子执行特性，如何实现不同代码块的互斥，并演示了嗅探锁定和多路通知功能，包括Condition对象的应用。通过实例展示，探讨了公平锁与非公平锁的区别和应用场景。
摘要由CSDN通过智能技术生成

ReentrantLock也能够让代码块原子执行，但是比synchronized更加强大，ReentrantLock具有嗅探锁定、多路分支通知等功能。

嗅探锁定：是指获取锁时如果锁已经被其他线程获取到ReentrantLock可以进行指定等待时间获取锁或者

多路分支通知：是指线程发生await时，线程可以选择注册在不同的监视器Condition对象上，在适当的时候可以选择指定的监视器Condition对象上的线程进行signal通知、执行

1、多线程执行同一代码块互斥

import java.util.concurrent.locks.ReentrantLock;

class MyService {

private ReentrantLock lock = new ReentrantLock();

public void method() {

try {

lock.lock();

for (int i = 1; i <= 3; i++) {

Thread.sleep(1000);

System.out.println("ThreadName=" + Thread.currentThread().getName() + " " + i);

}

} catch (InterruptedException e) {

e.printStackTrace();

}finally {

lock.unlock();

}

}

}

class MyThread extends Thread {

private MyService service;

MyThread(MyService service) {

this.service = service;

}

@Override

public void run() {

service.method();

}

}

public class Test {

public static void main(String[] args) {

MyService service = new MyService();

MyThread myThread1 = new MyThread(service);

MyThread myThread2 = new MyThread(service);

myThread1.start();

myThread2.start();

}

}

结果

ThreadName=Thread-0 1

ThreadName=Thread-0 2

ThreadName=Thread-0 3

ThreadName=Thread-1 1

ThreadName=Thread-1 2

ThreadName=Thread-1 3

2、多线程执行不同代码块互斥

import java.util.concurrent.locks.ReentrantLock;

class MyService {

private ReentrantLock lock = new ReentrantLock();

public void methodA() {

lock.lock();

try {

System.out.println("MethodA begin ThreadName=" + Thread.currentThread().getName());

for (int i = 1; i <= 3; i++) {

System.out.println("ThreadName=" + Thread.currentThread().getName() + " " + i);

Thread.sleep(1000);

}

System.out.println("MethodA end ThreadName=" + Thread.currentThread().getName());

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

lock.unlock();

}

}

public void methodB() {

lock.lock();

try {

System.out.println("MethodB begin ThreadName=" + Thread.currentThread().getName());

for (int i = 1; i <= 3; i++) {

System.out.println("ThreadName=" + Thread.currentThread().getName() + " " + i);

Thread.sleep(1000);

}

System.out.println("MethodB end ThreadName=" + Thread.currentThread().getName());

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

lock.unlock();

}

}

}

class ThreadA extends Thread {

private MyService service;

ThreadA(MyService service) {

this.service = service;

}

@Override

public void run() {

service.methodA();

}

}

class ThreadB extends Thread {

private MyService service;

ThreadB(MyService service) {

this.service = service;

}

@Override

public void run() {

service.methodB();

}

}

public class Test {

public static void main(String[] args) {

MyService service = new MyService();

ThreadA threadA = new ThreadA(service);

threadA.setName("A");

ThreadB threadB = new ThreadB(service);

threadB.setName("B");

threadA.start();

threadB.start();

}

}

结果：

MethodA begin ThreadName=A

ThreadName=A 1

ThreadName=A 2

ThreadName=A 3

MethodA end ThreadName=A

MethodB begin ThreadName=B

ThreadName=B 1

ThreadName=B 2

ThreadName=B 3

MethodB end ThreadName=B

3、多路通知

当多线程进入await状态时，利用Condition监视器对不同类型线程通知

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

class MyService {

private ReentrantLock lock = new ReentrantLock();

private Condition conditionA = lock.newCondition();

private Condition conditionB = lock.newCondition();

public void methodA() {

lock.lock();

try {

System.out.println("MethodA begin ThreadName=" + Thread.currentThread().getName() + " " + System.currentTimeMillis());

conditionA.await();

System.out.println("MethodA end ThreadName=" + Thread.currentThread().getName() + " " + System.currentTimeMillis());

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

lock.unlock();

}

}

public void methodB() {

lock.lock();

try {

System.out.println("MethodB begin ThreadName=" + Thread.currentThread().getName() + " " + System.currentTimeMillis());

conditionB.await();

System.out.println("MethodB end ThreadName=" + Thread.currentThread().getName() + " " + System.currentTimeMillis());

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

lock.unlock();

}

}

public void signalA() {

lock.lock();

conditionA.signal();

lock.unlock();

}

public void signalA_All() {

lock.lock();

conditionA.signalAll();

lock.unlock();

}

public void signalB() {

lock.lock();

conditionB.signal();

lock.unlock();

}

public void signalB_All() {

lock.lock();

conditionB.signalAll();

lock.unlock();

}

}

class ThreadA extends Thread {

private MyService service;

ThreadA(MyService service) {

this.service = service;

}

@Override

public void run() {

service.methodA();

}

}

class ThreadB extends Thread {

private MyService service;

ThreadB(MyService service) {

this.service = service;

}

@Override

public void run() {

service.methodB();

}

}

public class Test {

public static void main(String[] args) throws InterruptedException {

MyService service = new MyService();

ThreadA threadA = new ThreadA(service);

threadA.setName("A");

ThreadB threadB = new ThreadB(service);

threadB.setName("B");

threadA.start();

threadB.start();

Thread.sleep(1000);

service.signalA();

Thread.sleep(1000);

service.signalB();

// ThreadA[] threadAs = new ThreadA[10];

// for (int i=0;i<5;i++){

// threadAs[i] = new ThreadA(service);

// }

// ThreadB[] threadBs = new ThreadB[10];

// for (int i=0;i<5;i++){

// threadBs[i] = new ThreadB(service);

// }

//

// for (int i=0;i<5;i++){

// threadAs[i].start();

// threadBs[i].start();

// }

//

// Thread.sleep(1000);

// service.signalA_All();

// Thread.sleep(1000);

// service.signalB_All();

}

}

测试结果1：

MethodA begin ThreadName=A 1476800025028

MethodB begin ThreadName=B 1476800025029

MethodA end ThreadName=A 1476800026028

MethodB end ThreadName=B 1476800027028

修改代码为：

public static void main(String[] args) throws InterruptedException {

MyService service = new MyService();

// ThreadA threadA = new ThreadA(service);

// threadA.setName("A");

//

// ThreadB threadB = new ThreadB(service);

// threadB.setName("B");

// threadA.start();

// threadB.start();

//

// Thread.sleep(1000);

// service.signalA();

// Thread.sleep(1000);

// service.signalB();

ThreadA[] threadAs = new ThreadA[10];

for (int i=0;i<5;i++){

threadAs[i] = new ThreadA(service);

}

ThreadB[] threadBs = new ThreadB[10];

for (int i=0;i<5;i++){

threadBs[i] = new ThreadB(service);

}

for (int i=0;i<5;i++){

threadAs[i].start();

threadBs[i].start();

}

Thread.sleep(1000);

service.signalA_All();

Thread.sleep(1000);

service.signalB_All();

}

结果为：

MethodA begin ThreadName=Thread-0 1476800227416

MethodB begin ThreadName=Thread-7 1476800227417

MethodB begin ThreadName=Thread-5 1476800227417

MethodA begin ThreadName=Thread-3 1476800227418

MethodA begin ThreadName=Thread-1 1476800227418

MethodA begin ThreadName=Thread-4 1476800227418

MethodB begin ThreadName=Thread-6 1476800227418

MethodA begin ThreadName=Thread-2 1476800227418

MethodB begin ThreadName=Thread-8 1476800227418

MethodB begin ThreadName=Thread-9 1476800227418

MethodA end ThreadName=Thread-0 1476800228419

MethodA end ThreadName=Thread-3 1476800228419

MethodA end ThreadName=Thread-1 1476800228419

MethodA end ThreadName=Thread-4 1476800228420

MethodA end ThreadName=Thread-2 1476800228420

MethodB end ThreadName=Thread-7 1476800229419

MethodB end ThreadName=Thread-5 1476800229419

MethodB end ThreadName=Thread-6 1476800229419

MethodB end ThreadName=Thread-8 1476800229419

MethodB end ThreadName=Thread-9 1476800229419

4、公平所与非公平锁

公平锁是指线程获(getting)取锁的顺序和线程锁定(got)的顺序相同，

Lock的一些方法说明

A) getHoldCount()

获取当前锁定(got)的个数

B)getQueueLength()

获取当前正在等待获取(getting)锁的线程数(Threads)

C)getWaitQueueLength(Condition)

返回等待(await)与此锁定(got)的Condition相关的个数

综安驾校
关注
Java lock同步锁使用实例解析
08-25
在main方法中，创建了三个线程，分别调用run方法，run方法中使用Lock来实现同步锁，确保线程安全。 Java lock同步锁使用实例解析中，我们可以看到，Lock和synchronized都是Java并发编程中常见的同步锁机制，但是...
Java多线程中Lock锁的使用总结
08-18
Java多线程中Lock锁的使用总结 Java多线程中Lock锁的使用总结主要介绍了Java多线程中Lock锁的使用总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值。 知识点1: Java多线程中的...
java 中Lock的使用
weixin_33898233的博客
03-15 645
2019独角兽企业重金招聘Python工程师标准>>> ...
java lock用法_Java Lock的使用
weixin_42312392的博客
02-13 368
packagecom.zxd.concurrent.learning;importjava.util.concurrent.locks.ReentrantReadWriteLock;/***@authorCoderZZ* @Title: ${FILE_NAME}* @Project: ConcurrentLearning* @Package com.zxd.concurrent.learning*...
java Lock锁详解
最新发布
qq_42077317的博客
03-11 2060
1.公平锁：就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己。await(long time, TimeUnit unit)：使当前线程等待一段时间，在指定的时间内没有被其他线程调用signal()或signalAll()方法唤醒，将自动唤醒。await()：使当前线程等待，直到被其他线程调用signal()或signalAll()方法唤醒。
JAVA LOCK代码浅析
iteye_5347的博客
03-15 145
JAVA LOCK总体来说关键要素主要包括3点: 1.unsafe.compareAndSwapXXX(Object o,long offset,int expected,int x)2.unsafe.park() 和 unsafe.unpark()3.单向链表结构或者说存储线程的数据结构第1点主要为了保证锁的原子性，相当于一个锁是否正在被使用的标记，并且比较和设置这个标记的操作是原子的(硬件提供...
Java多线程之Lock使用深入理解
tian830937的专栏
03-19 2139
Lock锁的使用
LockPattern_java_totalgmj_
09-30
本文将以"LockPattern_java_totalgmj_"为实例，深入探讨如何使用Java语言实现一个类似于QQ的手势解锁系统。 一、概述 "LockPattern_java_totalgmj_"项目是一个基于Java编程语言的九宫格手势解锁程序。它通过用户在...
java Lock接口详解及实例代码
08-31
Java Lock接口是Java并发编程中一个重要的组成部分，它提供了一种更为灵活的锁机制，相比传统的`synchronized`关键字，Lock接口允许我们进行更细粒度的控制，包括可中断的锁等待、尝试获取锁以及定时等待等。...
Java锁机制Lock用法示例
08-27
在run方法中，我们使用lock()方法加锁，并在finally块中使用unlock()方法释放锁，以确保锁的释放。 在运行结果中，我们可以看到三个线程分别售出了票，并且每个线程都正确地释放了锁。 Java锁机制Lock用法示例展示...
Java中的Lock详解
向上的"狼"的博客
04-28 2万+
简介 java.util.concurrent.locks.Lock 是一个类似于synchronized 块的线程同步机制。但是 Lock比 synchronized 块更加灵活。Lock是个接口，有个实现类是ReentrantLock。 Lock和syncronized的区别
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用法_java中lock有哪几种用法
weixin_39819138的博客
02-13 1210
在之前讨论线程问题时，其安全性一直是我们使用的注意点。对于java中锁的使用，本篇主要基于lock讲起。从它的作用来看，我们会发现使用的灵活性和多个线程共享都得到了实现。下面我们对lock锁的作用详细介绍，并带来其六种用法的展示进行说明，下面一起来看具体的lock使用吧。1.作用(1)Lock方式来获取锁支持中断、超时不获取、是非阻塞的(2)提高了语义化，哪里加锁，哪里解锁都得写出来(3)Lock...
java中Lock的用法以及Lock与synchronized的区别
TimeTDIT的博客
12-10 2148
初识Lock以及Lock和synchronized的区别
Java多线程之Lock的使用
zhangziyueup
12-21 274
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.Re...
java中Lock类的使用
qq_41889292的博客
08-10 3688
1.使用ReentrantLock类： private Lock ticklock=new ReentrantLock(); 调用ReentrantLock对象的lock()方法获取锁，调用unlock()方法释放锁。 范例： public class MyThread{ private Lock lock=new ReentrantLock(); public...
Java锁--Lock实现原理(底层实现)
热门推荐
技术与生活齐头并进
09-01 3万+
关于java lock的底层实现原理，讲的有点深，转载学习！Lock完全用Java写成，在java这个层面是无关JVM实现的。在java.util.concurrent.locks包中有很多Lock的实现类，常用的有ReentrantLock、ReadWriteLock（实现类ReentrantReadWriteLock），其实现都依赖java.util.concurrent.AbstractQue
java lock四种用法
caideb的博客
12-27 2万+
1.普通用法 public static void testlock() { Lock lock = new ReentrantLock(); Thread t = new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub loc...
java锁的Lock的几种用法
小Y
08-09 8347
转载：https://segmentfault.com/q/1010000005602326 package concurrent; import java.util.ArrayList; import java.util.List; import java.util.concurrent.locks.Lock; import java.util.concurrent.lo
Java使用jedisLock实现Redis分布式锁示例
1. **系统分布式**：分布式锁只能在分布式系统中使用，单机环境通常有其他并发控制手段。 2. **共享资源**：所有参与节点都访问同一资源，例如数据库或 NoSQL 存储。 3. **同步访问**：确保多个进程对同一资源的访问...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值