从零开始java多线程到分布式锁（十一）：Lock的基本概念

最新推荐文章于 2023-12-04 17:21:04 发布
最新推荐文章于 2023-12-04 17:21:04 发布
阅读量232 收藏
点赞数
文章标签： lock的api
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35755863/article/details/103296902
版权

一：java中的锁

    java中的锁关键字分为3种：Lock、Synchronized以及volatile。

1 .Lock和Synchronized区别

    Lock: 为java中的显示锁，锁的获取和释放可以在不同的

   Synchronized：为java中隐石锁，所得获取和释放是在同步代码块的开始结束位置，是java实现同步的最简单的方法。

 

2.Synchronized和volatile的区别

 Synchronized：是java提供一个重量级别的锁，可以保证可见性、原子性等。

 volatile：是java5之后对于Synchronized优化的轻锁，可以保证多线程锁的可见性，但是原子性无法保证。

3.为什么不用Synchronized（valatitle）而采用Lock

 在上面几节我们谈到了Synchronized/volatitle的使用优化，尽然如此为什么还要用Lock呢？原因就是：前2种锁的加锁/解锁过程是针对读和写的。也就是如果一个方法既有读和写，其中读的频率有99%而写只有1%，Synchronized会将方法加锁导致99%读也会被加锁，而我们读操作是没有改变任何东西，只要读就行。因此Lock是为了消除Synchronized的读操作的加锁/解锁过程的。

二：Lock锁也是一个对象锁

  注意Lock也是一个对象锁，这就是说，一个对象一旦拥有多个加锁的方法，他也是同步执行的，代码如下：

1.没有锁的

package Lock;

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

/**
 * 验证Lock也是一个对象锁
 * @author monxz
 *
 */
public class ObjectLock {
	/**
	 * 定义Lock
	 */
 private Lock  lock=new ReentrantLock();
 
 public void  methodA() {
	 //加锁
//	 lock.lock();	 
	 try {
		 System.out.println("=====A方法开始执行");
		 for(int i =  0; i < 3 ;i ++){
			 System.out.println("=====线程执行方法A:"+Thread.currentThread().getName()+",顺序："+i);
			 Thread.sleep(1000);
		 }
		 System.out.println("=====A方法执行结束");
	} catch (Exception e) {
		e.printStackTrace();
	}finally {
		//解锁
//		lock.unlock();
	}	 
 }
 
 public void  methodB() {
	 //加锁
//	 lock.lock();	 
	 try {
		 System.out.println("=====B方法开始执行");
		 for(int i =  0; i < 3 ;i ++){
			 System.out.println("=====线程执行方法B:"+Thread.currentThread().getName()+",顺序："+i);
			 Thread.sleep(1000);
		 }
		 System.out.println("=====B方法执行结束");
	} catch (Exception e) {
		e.printStackTrace();
	}finally {
		//解锁
//		lock.unlock();
	}	 
 }
 
 public static void main(String[] args) {
	 
	/**
	 * ta，tb线程执行A，B俩个方法，注意这里ta，tb是同时执行的
	 */
	ObjectLock  lockService = new ObjectLock();
	ThreadA  ta =new ThreadA(lockService);
	ta.setName("ta");
	ta.start();	
	ThreadB tb =new ThreadB(lockService);
	tb.setName("tb");
	tb.start();
}
 
 
 
 
 
}
 
 //定义线程A类
 class ThreadA  extends Thread{
	 private ObjectLock  lockService;
	 public ThreadA(ObjectLock  ls){
		 this.lockService = ls;
	 }
	 @Override
	    public void run() {
		 lockService.methodA();
	    }
 }
 
 //定义线程B类
 class ThreadB  extends Thread{
	 private ObjectLock  lockService;
	 public ThreadB(ObjectLock  ls){
		 this.lockService = ls;
	 }
	 @Override
	    public void run() {
		 lockService.methodB();
	    }
 }

运行结果：注意A，B是同事执行的，没有顺序

2.使用Lock锁

这里只要把上面的A，B方法中的lock.lock()和lock.unlock（）注释即是A,B都加锁了。

运行结果：结果与上面比对就很明显了吧。

 

 

三：Lock锁的API

1.首先这里先截图出api

 

2.无锁多线程运行

 在无锁的情况下，多线程运行或出现没有顺序，这里上代码：

/**
 * 无锁多线程演示
 * @author monxz
 *
 */
class  NoLockTest  implements  Runnable{
	@Override
	public void run() {
		 for (int i = 0; i < 5; i++) {
	            
	            try {
	            	System.out.println(Thread.currentThread().getName() + "线程:执行顺序： "+i);
	                Thread.sleep(1000);
	            } catch (InterruptedException e) {
	                e.printStackTrace();
	            }
	        }	
	}	
}


	 public static void main(String[] args) {
		NoLockTest   test =new NoLockTest();


		for(int i = 0; i < 5 ; i++){
			Thread  thread  =  new Thread(test, "线程"+i);
			thread.start();
		}
	}

运行结果：

                                                                    

3.简单的Lock锁 

/**
 * 简单的lock演示
 * 说明：当前线程获取锁并且在执行方法，其他线程同时也获取锁，获取不到其他线程进入阻塞队列
 * @author monxz
 *
 */
class  onlysimpleLockTest implements  Runnable{
	Lock  lock  = new ReentrantLock();
	
	@Override
	public void run() {
		try {
			//加锁
			lock.lock();
			 for (int i = 0; i < 5; i++) {
				System.out.println(Thread.currentThread().getName() + "线程:执行顺序： "+i);
	            Thread.sleep(1000);
			 }		
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//释放锁
			lock.unlock();
		}
		
	}	
}

	 public static void main(String[] args) {
		
		onlysimpleLockTest   test =new onlysimpleLockTest();

		for(int i = 0; i < 5 ; i++){
			Thread  thread  =  new Thread(test, "线程"+i);
			thread.start();
		}
	}

运行结果（部分）：

4.简单的tryLock()

/**
 * 简单的tryLock（）演示
 * 说明：如果当前线程获取到锁并且执行中，那么其他线程获取不到锁，其他线程死亡
 * @author monxz
 *
 */
 class  tryLockTest implements  Runnable{
	Lock  lock  = new ReentrantLock();
	 @Override
	public void run() {
		if(lock.tryLock()){			            	            	
            try {
            	for (int i = 0; i < 5; i++) {
            	System.out.println(Thread.currentThread().getName() + "线程:执行顺序： "+i);
                Thread.sleep(1000);
            	}
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
            	lock.unlock();
            }	                       

		}else{
			System.out.println("线程"+Thread.currentThread().getName()+"没有获取锁！");
		}		
	}	 
 }

	 public static void main(String[] args) {		
		tryLockTest   test =new tryLockTest();
		for(int i = 0; i < 5 ; i++){
			Thread  thread  =  new Thread(test, "线程"+i);
			thread.start();
		}
	}

 运行结果：

5.tryLock(Long  time  timeUtil timeUtil) 

 /**
  * tryLock(time,timePS)添加时间等待
  * 说明：多线程中随机一个线程获取当前锁， 如果在当前线程在等待时间结束前没有执行完毕，其他线程全部放弃。如果执行完毕，剩余线程共同执行tryLock();
  * 示例：比如100个线程，第1个线程获取锁执行代码在等待时间结束前没有执行完成，其他99个线程放弃死亡。如果执行完毕，剩余的99个随机一个执行，其他98个死亡
  * @author monxz
  *
  */
 class  tryLockTimeTest implements  Runnable{
	Lock  lock  = new ReentrantLock();
	 @Override
	public void run() {
		 try {
			 if(lock.tryLock(1000,TimeUnit.MILLISECONDS)){			            	            			            
            	for (int i = 0; i < 5; i++) {
            	System.out.println(Thread.currentThread().getName() + "线程:执行顺序： "+i);
                Thread.sleep(1000);
            	}
           
            	 lock.unlock();
		            	                       

				}else{
					System.out.println("线程"+Thread.currentThread().getName()+"没有获取锁！");
				}
		} catch (Exception e) {
			e.printStackTrace();
		}				
	}
	 
 }
	 public static void main(String[] args) {

		 tryLockTimeTest   test =new tryLockTimeTest();
		for(int i = 0; i < 5 ; i++){
			Thread  thread  =  new Thread(test, "线程"+i);
			thread.start();
		}
	}
	
}

运行结果：

 

四：Lock的其他的一些api

getHoldCount() ：获取当前锁定（got）的个数 

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

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

源码： https://gitee.com/monxz/lock_of_java.git

qq_35755863
关注
专栏目录
从零开始java多线程到分布式锁（十二）：Lock的实现原理
qq_35755863的博客
12-04 233
一：Lock锁接口的实现方式ReentrantLock() ReentrantLock（）是已知唯一一个Lock的实现。在上文我们都使用ReentrantLock（）作为实现的。关于 二：Lock的特殊的Api-Condition 在上一节，我们谈到了Lock常用的一些接口方法Lock(),tryLock()等等。实则上Lock还有一个api我们单独拿出来说-condition。每...
从零开始java多线程到分布式锁（十三）：读写锁ReentrantReadWriteLock
qq_35755863的博客
12-04 344
一：读写锁的引入 我们在实际项目中，即使在一些使用锁的方法下也是基本以读为主写为辅，那么在大多数的读的情况下，如果也是用排它锁（即一个线程获取到锁，其他线程就进入阻赛了）就会导致是项目效率降低。有没有这样这样一种锁，读锁是排它锁，写是共享锁。 在java中提供这样一种锁：ReentrantReadWriteLock。该接口维护了一组共2个锁。其中读锁是共享锁，写锁是互斥锁。 二...
JAVA多线程基础：ReadWriteLock读写锁简单实现
yuanyuneixin1的专栏
05-11 239
介绍 刚开始一听这名字就有些懵逼，写要加锁我明白，读为啥还要加锁啊？看了别人博客后才明白 读写锁允许同一时刻被多个读线程访问，但是在写线程访问时，所有的读线程和其他的写线程都会被阻塞。 原来是怕读入脏输入啊，为了保证每次读到的数据都是最新修改的数据，好吧！这个代码也挺简单的，直接上代码吧！ 代码 创建读写锁的对象 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantReadWriteLo
RedLock算法实现分布式锁思路
Java持续实践
05-29 237
笔记来源: Java工程师面试突击专栏 https://apppukyptrl1086.pc.xiaoe-tech.com/detail/p_5d3114935b4d7_CEcL8yMS/6 文章目录RedLock算法实现分布式锁思路 RedLock算法实现分布式锁思路 场景: 有一个redis cluster 集群, 五个Redis的集群, 每一个master 都有一个slave 获取当前的时间戳, 单位毫秒, 用于计算创建锁的时间 某个系统尝试在每个master node上都去上锁 , 设置的过期
JAVA实现分布式锁
tttttt521的博客
07-08 1460
场景：若某商品库存量为50，存入redis，有一个功能：从redis将库存量读取出来，如果库存大于0，便对库存进行减一操作代表被买走一个，当库存小于0时提示库存不足 搭建场景demo 查看Redis中的库存量 引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis<...
从零开始java多线程到分布式锁（十）：volatile的使用以及优化
qq_35755863的博客
12-02 318
一：volatile关键字的使用 Synchronized锁一个重锁，其本质依赖于JVM核的Monitor的监控。实则上一旦使用偏锁/轻锁的优化在很多程度上会导致代码运行效率不高（原因就是多次CAS操作导致的）。因此，java引入另外一个关键字volatitle，但是说实话这个关键字的使用还是很少的，主要原因就是volatitle只能保证单次的读或者写的同步性，一旦一个方法出现对一个变量既有读...
【Redis】Redis高级：分布式锁
qq_50675319的博客
09-20 1016
上述任务的执行时间我们可以看到，是internalLockLeaseTime / 3，那么这个internalLockLeaseTime又是多少呢？其实这里的internalLockLeaseTime和我们之前提到的看门狗过期时间是同一个时间，也就是30秒，也就是说这里任务的执行时间就是10秒之后，而每当我们执行一次任务之后，任务内部又会再次调用renewExpiration()，也就是说这段任务每隔10秒就会执行一次，刷新当前线程持有锁的有效期，模拟一个锁永不过期的效果，这个任务也就被称为"看门狗"
redisson分布式锁实现原理
m0_67393828的博客
06-12 5403
一般写法如下： 其实redis分布式锁就是基于redis的hash数据类型实现的，key为：锁名称，即myLock，field为：uuid+threadId，value为：上锁次数，从此可以看出redis锁是可重入的 二：上锁lock 上面值得注意的是：综上： 个人觉得还是指定合适的leaseTime好，能确保系统出现故障未释放锁后，在一定时间内能够主动去释放锁，避免造成死锁获取锁的整体流程： 模拟多线程同时请求锁的情况： （注意redis中锁值得变化） 释放锁的整理流程：锁续时：使用默认过期时间上锁
Java锁——分布式锁整理
泯灭于众生，高歌于孤夜！
01-25 937
引入业务场景 首先来由一个场景引入： 最近老板接了一个大单子，允许在某终端设备安装我们的APP，终端设备厂商日活起码得几十万到百万级别，这个APP也是近期产品根据市场竞品分析设计出来的，几个小码农通宵达旦开发出来的，主要功能是在线购物一站式服务，后台可以给各个商家分配权限，来维护需要售卖的商品信息。 老板大O：谈下来不容易，接下来就是考虑如何吸引终端设备上更多的用户注册上来，如何引导用户购买，这块就交给小P去负责了，需求尽快做，我明天出差！ 产品小P：嘿嘿~，眼珠一转儿，很容易就想到了，心里想：“这还不简单
java 线程锁 可重入锁 可中断锁 公平锁 非公平锁ReentrantLock synchronized,条件Condition,读写锁 ReentrantReadWriteLock写写互斥读读共享
银河系天城知识宝库_技术专家蒋浩宇
05-06 333
目录 介绍 synchronized 修饰方块执行顺序 lock 提供了更加灵活的方式实现 lock 接口 这玩意应用场景 加锁和释放锁示例 lock普通获取锁 tryLock() 中断锁 newCondition() Lock接口的实现类：可重入锁 ReentrantLock 主要方法 ReentrantLock 锁示例 lock示例 结果日志 tryLock 锁 结果 lock.tryLock(1000,TimeUnit.SECONDS) lockInterrupt.
深入理解AQS底层源码(一)——lock.lock()
闻臻
11-19 1328
前期准备： 1、可重入锁（递归锁）：外层使用锁后，在内层仍然可以使用锁。同一个线程可以获取多个同一把锁。 优点：避免死锁。特点：锁对象是同一个对象 2、LockSupport：LockSupport.park(); LockSupport.unPark(Thread t); 类比 synchronized wait notify ； lock.newCondition await signal wait notify必须和synchronized搭配使用且先wait后notify； awai...
lock.lock()使用，与synchronized对比
技匠而已
02-18 3246
Lock锁 锁实现提供了比使用synchronized方法和语句更广泛的锁操作。它们允许更灵活的结构，可能有不同的属性，可能支持多个关联的Condition对象。 锁是用于控制多个线程对共享资源的访问的工具。 通常，锁提供对共享资源的独占访问:一次只有一个线程可以获得锁，并且所有访问共享资源的访问都需要先获得锁。但是，有些锁可能允许并发访问共享资源。例如readwritellock的读锁。 同步方法或语句的使用提供了对每个对象关联的隐式监视器锁的访问，但强制所有锁的获取和释放都以块结构的方式进行:当多个锁
多线程学习笔记（六）之锁对象Lock
Megustas_JJC的博客
05-05 1091
接口Lock首先我们回顾下同步代码块，例如：Object obj = new Object(); void show(){ synchronized(obj){ code... } }同步代码块对锁的操作是隐式的，执行完同步代码块中的内容，自动释放锁。而Lock将锁封装成为了对象，即把对锁操作的隐式操作换成了显示操作。可以将如上代码改写：Lock lock = new
Java中Lock锁详解
mercedes_benz
07-08 7229
在Java中，Lock是一个接口，它提供了比关键字更高级的线程同步机制。使用Lock接口可以创建更复杂和灵活的同步结构。Lock接口的常用实现类有ReentrantLock和ReentrantReadWriteLock，它们提供了可重入的互斥锁和读写锁。使用Lock锁的一般步骤如下：1. 创建一个`Lock`对象实例。2. 在需要进行同步的代码块中，通过调用`lock()`方法来获取锁。3. 在同步的代码块执行完之后，通过调用`unlock()`方法释放锁。
深入学习锁--Lock各种使用方法
最新发布
weixin_42672802的博客
12-04 1686
深入学习锁--Lock各种使用方法
Lock锁的使用
u014754272的博客
03-20 317
   在Java多线程中，可以使用synchronized关键字实现线程之间的同步互斥，在jdk1.5后新增的ReentrantLock类同样可达到此效果，且在使用上比sy...
java中的Lock锁
热门推荐
纯洁的小魔鬼
07-15 1万+
一. 概述 Lock 是 java.util.concurrent.locks 包 下的接口，Lock 实现提供了比 synchronized 关键字 更广泛的锁操作，它能以更优雅的方式处理线程同步问题。Lock提供了比synchronized更多的功能。 1.Lock和ReadWriteLock是两大锁的根接口，Lock代表实现类是ReentrantLock（可重入锁），ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock。 　2.Lock 接口支...
lock（锁）
zhuwukai的博客
08-18 674
locklock于synchronized相比更有优势，或者是说有不同的地方。lock于synchronized的区别？synchronized一个线程获取锁别的线程都在等待，synchronized当前的方法或者代码块会自动释放锁，然后让别的线程去获取。synchronized代码块抛出异常也会自动释放锁lock就是一个线程获取锁，别的线程会尝试获取锁，如果获取多的话也没关系，也不会等待，做别的...
Java多线程同步与锁详解：避免数据破坏
3. **Lock接口与ReentrantLock**：Java提供了更高级的锁机制，如`java.util.concurrent.locks.Lock`接口及其实现类`ReentrantLock`。相比`synchronized`，`Lock`提供了更细粒度的控制，如尝试获取锁、可中断的锁等待...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值