ReentrantLock使用详解(1)之lock/unlock

最新推荐文章于 2023-06-18 15:33:22 发布
最新推荐文章于 2023-06-18 15:33:22 发布
阅读量1.3k 收藏
点赞数
分类专栏： Java并发编程 文章标签： java 可重入锁

在大多数实际的多线程应用中，两个或两个以上的线程需要共享对同一数据的存取。如果两个线程存取相同的对象，并且每一个线程都调用了一个修改该对象状态的方法，那么线程彼此踩了对方的脚，根据各线程访问数据的次序，可能会产生讹误的对象。这样的一种现象称之为竞争条件。

当然多个线程共享一个变量在实际的应用中有时难以避免，但是我们可以通过java提供的一些技术来避免线程彼此踩脚的行为发生。

java提供了锁机制来对多个线程共享一个变量进行同步，在Java SE 5.0引入了显式锁ReentrantLock类，以及从1.0版本开始的对象内部锁 可以通过synchronized关键字声明某个线程持有这个对象内部锁，我们这小结先学习ReentrantLock锁的使用，下一节学习synchronized关键字的使用。


(1) ReentrantLock锁的使用结构

ReentrantLock 是java.unti.concurrent包下的一个类，它的一般使用结构如下所示：

[java] view plain copy print ?
  1. public void lockMethod() {  
  2.     ReentrantLock myLock = new ReentrantLock();  
  3.     myLock.lock();  
  4.     try{  
  5.         // 受保护的代码段  
  6.         //critical section  
  7.     } finally {  
  8.         // 可以保证发生异常 锁可以得到释放 避免死锁的发生  
  9.         myLock.unlock();  
  10.     }  
  11. }  
public void lockMethod() {
	ReentrantLock myLock = new ReentrantLock();
	myLock.lock();
	try{
		// 受保护的代码段
		//critical section
	} finally {
		// 可以保证发生异常 锁可以得到释放 避免死锁的发生
		myLock.unlock();
	}
}

把解锁操作括在finally字句之内是至关重要的，如果受保护的代码抛出异常，锁可以得到释放，这样可以避免死锁的发生

我们执行下面代码：

[java] view plain copy print ?
  1. public class ReentrantLockTest1 {  
  2.       
  3.     private int num = 10;  
  4.     private ReentrantLock myLock = new ReentrantLock();  
  5.     public void writeNumMethod() {    
  6.         //myLock.lock();  
  7.         try{  
  8.             // 受保护的代码段  
  9.             int index =10;  
  10.             while(index > 0) {  
  11.                 System.out.println(Thread.currentThread().getName() + " : "+ num);  
  12.                 num-=10;  
  13.                 long beginTime = System.currentTimeMillis();  
  14.                 while(System.currentTimeMillis() - beginTime < 10){}  
  15.                 num+=10;  
  16.                 System.out.println(Thread.currentThread().getName() + " : "+ num);  
  17.                 index--;  
  18.             }  
  19.   
  20.     } finally {  
  21.             // 可以保证发生异常 锁可以得到释放 避免死锁的发生  
  22.             //myLock.unlock();  
  23.         }  
  24.     }  
  25.       
  26.     public void readNumMethod() {     
  27.         //myLock.lock();  
  28.         try{  
  29.             int index = 10;  
  30.             // 受保护的代码段  
  31.             while(index > 0) {  
  32.                 System.out.println(Thread.currentThread().getName() + " : "+ num);  
  33.                 index--;  
  34.             }  
  35.   
  36.     } finally {  
  37.             // 可以保证发生异常 锁可以得到释放 避免死锁的发生  
  38.             //myLock.unlock();  
  39.         }  
  40.     }  
  41.       
  42.       
  43.     public static void main(String [] args) {  
  44.         final ReentrantLockTest1 myLockTest = new ReentrantLockTest1();  
  45.           
  46.         Thread t1 = new Thread(new Runnable() {  
  47.             public void run() {  
  48.                 myLockTest.writeNumMethod();  
  49.             }  
  50.         },"A");  
  51.           
  52.         Thread t2 = new Thread(new Runnable() {  
  53.             public void run() {  
  54.                 myLockTest.readNumMethod();  
  55.             }  
  56.         },"B");  
  57.           
  58.         t1.start();  
  59.         t2.start();  
  60.     }  
  61. }  
public class ReentrantLockTest1 {
	
	private int num = 10;
    private ReentrantLock myLock = new ReentrantLock();
	public void writeNumMethod() {	
		//myLock.lock();
		try{
			// 受保护的代码段
			int index =10;
			while(index > 0) {
				System.out.println(Thread.currentThread().getName() + " : "+ num);
				num-=10;
				long beginTime = System.currentTimeMillis();
				while(System.currentTimeMillis() - beginTime < 10){}
				num+=10;
				System.out.println(Thread.currentThread().getName() + " : "+ num);
				index--;
			}

	} finally {
			// 可以保证发生异常 锁可以得到释放 避免死锁的发生
			//myLock.unlock();
		}
	}
	
	public void readNumMethod() {	
		//myLock.lock();
		try{
			int index = 10;
			// 受保护的代码段
			while(index > 0) {
				System.out.println(Thread.currentThread().getName() + " : "+ num);
				index--;
			}

	} finally {
			// 可以保证发生异常 锁可以得到释放 避免死锁的发生
			//myLock.unlock();
		}
	}
	
	
	public static void main(String [] args) {
		final ReentrantLockTest1 myLockTest = new ReentrantLockTest1();
		
		Thread t1 = new Thread(new Runnable() {
			public void run() {
				myLockTest.writeNumMethod();
			}
		},"A");
		
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				myLockTest.readNumMethod();
			}
		},"B");
		
		t1.start();
		t2.start();
	}
}


上面示例中 writeNumMethod方法 对num变量进行先减10 然后再加10，readNumMethod方法读取num的值，线程A执行writeNumMethod方法，线程B执行readNumMethos方法，我们期望两个线程的 输出的结果都是10，但是由于我们没有对这个共享变量num 进行同步，假如此时线程A执行到num-=10这句代码时，线程的cpu时间片到时了，这时操作系统就会去调度线程B这样线程B就会输出0值。我们看一输出结果。

输出结果：

[java] view plain copy print ?
  1. A : 10  
  2. B : 10  
  3. B : 0  
  4. B : 0  
  5. B : 0  
  6. B : 0  
  7. B : 0  
  8. B : 0  
  9. B : 0  
  10. B : 0  
  11. B : 0  
  12. A : 10  
  13. A : 10  
  14. A : 10  
  15. A : 10  
  16. A : 10  
  17. A : 10  
  18. A : 10  
  19. A : 10  
  20. A : 10  
  21. A : 10  
  22. A : 10  
  23. A : 10  
  24. A : 10  
  25. A : 10  
  26. A : 10  
  27. A : 10  
  28. A : 10  
  29. A : 10  
  30. A : 10  
A : 10
B : 10
B : 0
B : 0
B : 0
B : 0
B : 0
B : 0
B : 0
B : 0
B : 0
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10


果然共享变量出现了讹误的现象。

那么如果我们取消代码中显式锁前的注释，再次运行代码。

[java] view plain copy print ?
  1. A : 10  
  2. A : 10  
  3. A : 10  
  4. A : 10  
  5. A : 10  
  6. A : 10  
  7. A : 10  
  8. A : 10  
  9. A : 10  
  10. A : 10  
  11. A : 10  
  12. A : 10  
  13. A : 10  
  14. A : 10  
  15. A : 10  
  16. A : 10  
  17. A : 10  
  18. A : 10  
  19. A : 10  
  20. A : 10  
  21. B : 10  
  22. B : 10  
  23. B : 10  
  24. B : 10  
  25. B : 10  
  26. B : 10  
  27. B : 10  
  28. B : 10  
  29. B : 10  
  30. B : 10  
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
B : 10
B : 10
B : 10
B : 10
B : 10
B : 10
B : 10
B : 10
B : 10
B : 10

输出结果是显式锁很好的保护了 writeNumMethod 的操作，假设线程A在执行结束前被剥夺了运行权，这是线程B调用readNumMethod方法去读取num的值，但是由于线程B不能获得锁，线程B必须等待线程A释放锁才能执行readNumMethod方法。这样就保证了writeNumMethod方法的原子性，也就保证了共享变量num不会出现讹误的现象。

(2)ReentrantLock是可重入锁

ReentrantLock持有一个所计数器，当已持有所的线程再次获得该锁时计数器值加1，每调用一次lock.unlock()时所计数器值减一，直到所计数器值为0，此时线程释放锁。

我们测试以下代码：

[java] view plain copy print ?
  1. public class ReentrantLockTest2 {  
  2.       
  3.     private ReentrantLock lock = new ReentrantLock();  
  4.       
  5.     public void testReentrantLock() {  
  6.         // 线程获得锁  
  7.         lock.lock();  
  8.         try {  
  9.             System.out.println(Thread.currentThread().getName() + " get lock");  
  10.             long beginTime = System.currentTimeMillis();  
  11.             while(System.currentTimeMillis() - beginTime < 100){}  
  12.             lock.lock();  
  13.             try {  
  14.                 System.out.println(Thread.currentThread().getName() + " get lock again");  
  15.                 long beginTime2 = System.currentTimeMillis();  
  16.                 while(System.currentTimeMillis() - beginTime2 < 100){}  
  17.             }finally {  
  18.                 // 线程释放锁  
  19.                 lock.unlock();  
  20.                 System.out.println(Thread.currentThread().getName() + " release lock");  
  21.             }  
  22.         } finally {  
  23.             // 线程释放锁  
  24.             lock.unlock();  
  25.             System.out.println(Thread.currentThread().getName() + " release lock again");  
  26.         }  
  27.     }  
  28.     public static void main(String[] args) {  
  29.         // TODO Auto-generated method stub  
  30.         final ReentrantLockTest2 test2 = new ReentrantLockTest2();  
  31.         Thread thread = new Thread(new Runnable(){  
  32.             public void run() {  
  33.                 test2.testReentrantLock();  
  34.             }  
  35.         },"A");  
  36.         thread.start();  
  37.     }  
  38.   
  39. }  
  40.   
  41. 输出结果：  
  42. A get lock  
  43. A get lock again  
  44. A release lock  
  45. A release lock again  
public class ReentrantLockTest2 {
	
	private ReentrantLock lock = new ReentrantLock();
	
	public void testReentrantLock() {
		// 线程获得锁
		lock.lock();
		try {
			System.out.println(Thread.currentThread().getName() + " get lock");
			long beginTime = System.currentTimeMillis();
			while(System.currentTimeMillis() - beginTime < 100){}
			lock.lock();
			try {
				System.out.println(Thread.currentThread().getName() + " get lock again");
				long beginTime2 = System.currentTimeMillis();
				while(System.currentTimeMillis() - beginTime2 < 100){}
			}finally {
				// 线程释放锁
				lock.unlock();
				System.out.println(Thread.currentThread().getName() + " release lock");
			}
		} finally {
			// 线程释放锁
			lock.unlock();
			System.out.println(Thread.currentThread().getName() + " release lock again");
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		final ReentrantLockTest2 test2 = new ReentrantLockTest2();
		Thread thread = new Thread(new Runnable(){
			public void run() {
				test2.testReentrantLock();
			}
		},"A");
		thread.start();
	}

}

输出结果：
A get lock
A get lock again
A release lock
A release lock again

零度anngle
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ReentrantLock的使用及注意事项
12-19
ReentrantLock的使用及注意事项
ReentrantLock源码详解--条件锁
08-25
ReentrantLock源码详解中最重要的一个部分就是条件锁，条件锁是指在获取锁之后发现当前业务场景自己无法处理，而需要等待某个条件的出现才可以继续处理时使用的一种锁。今天我们来详细介绍条件锁的原理和实现。 ...
ReentrantLock的lock-unlock流程详解
热门推荐
luonanqin的专栏
12-11 2万+
在jdk1.5之前，多线程之间的同步是依靠synchronized来实现。synchronized是java的关键字，直接由jvm解释成为指令进行线程同步管理。因为操作简单，而且现在jdk的后续版本已经对synchronized进行了很多的优化，所以一直是大家编写多线程程序常用的同步工具。那为什么要推出新的同步api呢？jdk1.5发布的时候，synchronized性能并不好，这可能是concurrent包出现的一个潜在原因，但是更重要的是新的api提供了更灵活，更细粒度的同步操作，以满足不同的需求。但是
并发编程学习总结(四) ：java 显式锁ReentrantLock使用详解之lock()\unlock() 加锁与释放锁
远方和诗 的博客
05-17 5576
在大多数实际的多线程应用中，两个或两个以上的线程需要共享对同一数据的存取。如果两个线程存取相同的对象，并且每一个线程都调用了一个修改该对象状态的方法，那么线程彼此踩了对方的脚，根据各线程访问数据的次序，可能会产生讹误的对象。这样的一种现象称之为竞争条件。 当然多个线程共享一个变量在实际的应用中有时难以避免，但是我们可以通过java提供的一些技术来避免线程彼此踩脚的行为发生。 java提供了
ReentrantLock 使用方法
FLY_THINK2012的博客
03-18 269
ReentrantLock是jdk5引入的新的锁机制，它与内部锁（synchronize） 相同的并发性和内存语义，比如可重入加锁语义。在中等或者更高负荷下，ReentrantLock有更好的性能，并且拥有可轮询和可定时的请求锁等高级功能。这个程序简单对比了ReentrantLock公平锁、ReentrantLock非公平锁以及内部锁的性能，从结果上看，非公平的ReentrantLock...
ReentrantLock使用
qq_39403359的博客
12-05 159
ReentrantLock简单使用 ReentrantLock为手动锁，必须手动释放锁。 创建：Lock lock = new ReentrantLock(); 加锁： lock.lock();（等同与synchronized(this)） 手动释放锁： unlock(); 窥探是否存在锁： boolean tryLock();直接查询是否存在锁 boolean tryLock(long tim...
ReentrantLock源码详解--公平锁、非公平锁
08-25
ReentrantLock源码详解--公平锁、非公平锁 ReentrantLock是一种重入锁，实现了Lock接口，能够对共享资源重复加锁，即当前线程获取该锁再次获取不会被阻塞。ReentrantLock的可重入性是通过继承AQS...
ReentrantLock实现原理详解
08-31
《ReentrantLock实现原理详解》 ReentrantLock作为Java并发编程中的重要工具，相较于内置关键字`synchronized`，它提供了更灵活、更强大的锁控制能力。本文将深入探讨ReentrantLock的实现原理，包括其与`...
java ReentrantLock详解
08-26
Java ReentrantLock 详解 Java ReentrantLock 是 Java 1.5 中引入的锁机制，相比于传统的 synchronized 锁，它提供了更加灵活和强大的功能。ReentrantLock 是一种可重入锁，意味着同一个线程可以多次获得锁，而不会...
Java多线程 ReentrantLock互斥锁详解
08-25
Java多线程ReentrantLock互斥锁详解 ReentrantLock是Java多线程编程中的一种锁机制，它可以实现线程之间的同步访问资源。ReentrantLock的主要特点是可以重入，即一个线程可以多次获得锁，而不需要释放锁。这种机制...
ReentrantLock的使用
学渣的博客
05-28 604
一、初识ReentrantLock（ReentrantLock 实现了Lock interface） import java.util.concurrent.locks.ReentrantLock; /** * Created by haicheng.lhc on 17/05/2017. * * @author haicheng.lhc * @date 2017/05/17 */ public class ReentrantLockTest extends Thread { pu.
reentrantlock的使用
yxking1的专栏
03-09 158
reentrantlock可以用来代替synchronized 使用syn锁定的话如果遇到异常，jvm会自动释放锁，但是lock必须手动释放锁，因此经常在finally中进行锁的释放 class ReentrantLockDemo{ synchronized void m1(){ for (int i = 0; i < 10; i++) { ...
ReentrantLock的使用。
qq_43184813的博客
04-24 224
ReentrantLock的使用
ReentrantLock
噬日者
02-28 1万+
synchronized原语和ReentrantLock在一般情况下没有什么区别，但是在非常复杂的同步应用中，请考虑使用ReentrantLock，特别是遇到下面2种需求的时候。 1.某个线程在等待一个锁的控制权的这段时间需要中断 2.需要分开处理一些wait-notify，ReentrantLock里面的Condition应用，能够控制notify哪个线程 3.具有公平锁功能，每个
ReentrantLock类的使用
NULL的博客
11-03 314
一、使用ReentrantLock类 和 synchronized 关键字来实现线程之间的同步互斥一样，ReentrantLock 类也可以达到这样的效果 class MyService2 { private Lock lock = new ReentrantLock(); public void methodA() { //当前线程获得对象锁 ...
ReentrantLock之lock、unlock
最新发布
程序员海绵的博客
06-18 137
尝试加锁，加锁成功就返回，失败就入队。执行完成后要唤醒队首节点。可打断原理不可打断模式我们首先来看一下不可打断模式，这也是ReentrantLock的默认模式。核心在于我们分析的selfInterrupt。该方法表面上看是要打断当前线程，但其实不然，在Java中打断当前线程，当前线程并不会立刻停止运行，只是设置一个被打断的标志，线程可以通过该标志判断自己是否被打断过，如果被打断后，则可以执行被打断的逻辑。而如果想打断当前线程，可以使用lockInterruptibly方法。if(!
ReentrantLock 中的trylock方法详解
04-22
ReentrantLock 中的 tryLock() 方法是一个非阻塞式的尝试获取锁的方法。该方法会尝试获取锁，如果锁没有被其他线程占用，则获取锁成功，返回 true，表示已经获得了锁，可以继续执行后面的代码。如果锁已经被其他线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值