Java多线程之Lock锁的线程交互

最新推荐文章于 2022-11-22 20:37:23 发布
最新推荐文章于 2022-11-22 20:37:23 发布
阅读量503 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 线程 文章标签： lock tryLock 多线程交互
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/carson0408/article/details/79439462
本文详细介绍了Java中的Lock机制，对比了lock与synchronized关键字的区别，深入解析了lock()与tryLock()方法的功能及应用场景，并通过实例展示了如何使用ReentrantLock进行线程间的交互。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

        之前创建锁的方式中，有说过Lock机制，并且比较了synchronized和lock的区别。本文主要讲解一下lock锁的功能以及实现线程交互。

1.lock()方法与tryLock()方法

        lock()方法指占用一个锁，当前线程占用这个对象，则其它线程则只能进入等待状态，而tryLock()方法，则是试图在指定时间内占用当前同步对象，如果占用不了继续等待，其它线程试图抢占。

        首先是lock()方法进行加锁，因为lock机制进行加锁，需要手动释放锁，只能在finally中调用lock对象的unlock()方法释放锁。

package waytobuildthread;

import person.Student;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.*;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ThreadTest {

	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		final Lock lock=new ReentrantLock();
		
		
		Thread t1= new Thread(){
	           public void run(){
	            try
	            {
	            	lock.lock();
	            	System.out.println("b");
		        	
		        	System.out.println("c");
	            }
	            
	        	finally
	        	{
	        		lock.unlock();
	        	}
	           }  
	       };
	       t1.start();
	        
		
		
		
	       Thread t2= new Thread(){
	           public void run(){
	            try
	            {
	            	lock.lock();
		        	System.out.println("a");
		        	
		        	System.out.println("c");
	            }
	        	finally
	        	{
	        		lock.unlock();
	        	}
	           }
	            	
        		
	            	
	            
	       };
        t2.start();
	        
		
		
		

	}

}
b
c
a
c
        以下是使用tryLock()进行同步对象，因为是尝试加锁，所以需要用一个locked的布尔值进行判断是否加锁，只有加锁了才进行继续操作，以及释放锁操作。首先需要Lock lock=new ReentrantLock();创建lock对象。
package person;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.*;
import java.util.concurrent.locks.Condition;;
public class Student {
	public int k=0;
	public int total;
	public int perMonth;
	public String name;
	Lock lock=new ReentrantLock();
	Condition condition=lock.newCondition();//创建condition对象
	
	public void saveMoney(Student s) {
		// TODO Auto-generated method stub
		
		try
		{
			lock.lock();
			while(total>=3000)
			{
				try
				{
					condition.await();
				}
				catch(InterruptedException e)
				{
					e.printStackTrace();
				}
			}
			
			s.total=s.total+2*(s.perMonth);
			System.out.println(s.name+"存了"+2*s.perMonth+"当前总共拥有"+s.total+"元");
	
			condition.signal();
			
		}
		
		finally
		{
			lock.unlock();
			
			
		}
			
		
	}
	public void getMoney(Student s)
	{
		
		try
		{
			lock.lock();
			while(s.total<=0)
			{
				try
				{
					condition.await();//使当前线程暂停，让出占用当前同步对象的锁，并进入等待状态
				}
				catch(InterruptedException e)
				{
					e.printStackTrace();
				}
			}
			
			s.total=s.total-s.perMonth;
			System.out.println(s.name+"取了"+s.perMonth+"当前总共拥有"+s.total+"元");	

			condition.signal();//唤醒那些暂停的线程，使其进入等待列表，类似于synchronized下的notify()方法
		
		}
		
		finally
		{
			lock.unlock();
			
			
		}
		


	}

}

运行程序，结果如下：

b
c
a
c

2.线程交互

        以上讲述了lock锁中的lock方法和tryLock()方法进行创建同步对象的，所以接下来就分别这两个方法进行交互，之前synchronized下的交互是由同步对象的wait()、notify()、notifyAll()三个方法实现的，而上述三个方法只能在synchronized块下进行使用，因此无法在lock锁中使用，而lock锁下实现交互对应的方法是condition对象的await()、signal()、signalAll()方法。

以下先介绍测试程序：

package waytobuildthread;

import person.Student;

public class RunnableTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		final Object obj=new Object();
		final Student s=new Student();
		final Student jack=new Student();
		s.total=1000;
		s.perMonth=200;
		s.name="Tom";
		System.out.println("Tom最开始拥有"+s.total+"元");
		Thread[] save=new Thread[10];
		Thread[] get=new Thread[10];
		for(int i=0;i<10;i++)
		{
			Thread t1= new Thread(){
	            public void run(){
	            	
	            	
	            	s.getMoney(s);;
	            	
	        		try {
	        			Thread.sleep(1000);;
	        		}
	        		catch(InterruptedException e) {
	        			e.printStackTrace();
	        		}
	            	
	            }
	        };
	        t1.start();
	        get[i]=t1;
		}
		
		for(int i=0;i<10;i++)
		{
			Thread t2= new Thread(){
	            public void run(){
	            	
	            	s.saveMoney(s);
	            	
	            	
	        		try {
	        			Thread.sleep(1000);;
	        		}
	        		catch(InterruptedException e) {
	        			e.printStackTrace();
	        		}
	            	
	            }
	        };
	        t2.start();
	        save[i]=t2;
		}
		//等待线程结束
		for(Thread t:get)
		{
			try
			{
				t.join();
				
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}

		}
		//等待线程结束
		for(Thread t:save)
		{
			try
			{
				t.join();
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}

		}
		
		System.out.println("最后Tom总共拥有"+s.total+"元");
		
	}

}

        首先使用lock()方法同步下进行交互，需要创建Lock对象，以及condition()对象。注意lock锁需要手动释放锁，即在finally中调用Lock对象的unlock()方法。以下是Student类：

package person;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.*;
import java.util.concurrent.locks.Condition;;
public class Student {
	public int k=0;
	public int total;
	public int perMonth;
	public String name;
	Lock lock=new ReentrantLock();
	Condition condition=lock.newCondition();//创建condition对象
	
	public void saveMoney(Student s) {
		// TODO Auto-generated method stub
		
		try
		{
			lock.lock();
			while(total>=3000)
			{
				try
				{
					condition.await();
				}
				catch(InterruptedException e)
				{
					e.printStackTrace();
				}
			}
			
			s.total=s.total+2*(s.perMonth);
			System.out.println(s.name+"存了"+2*s.perMonth+"当前总共拥有"+s.total+"元");
	
			condition.signal();
			
		}
		
		finally
		{
			lock.unlock();
			
			
		}
			
		
	}
	public void getMoney(Student s)
	{
		
		try
		{
			lock.lock();
			while(s.total<=0)
			{
				try
				{
					condition.await();//使当前线程暂停，让出占用当前同步对象的锁，并进入等待状态
				}
				catch(InterruptedException e)
				{
					e.printStackTrace();
				}
			}
			
			s.total=s.total-s.perMonth;
			System.out.println(s.name+"取了"+s.perMonth+"当前总共拥有"+s.total+"元");	

			condition.signal();//唤醒那些暂停的线程，使其进入等待列表，类似于synchronized下的notify()方法
		
		}
		
		finally
		{
			lock.unlock();
			
			
		}
		


	}

}

运行测试程序，结果如下：

Tom最开始拥有1000元
Tom取了200当前总共拥有800元
Tom取了200当前总共拥有600元
Tom取了200当前总共拥有400元
Tom取了200当前总共拥有200元
Tom取了200当前总共拥有0元
Tom存了400当前总共拥有400元
Tom存了400当前总共拥有800元
Tom取了200当前总共拥有600元
Tom存了400当前总共拥有1000元
Tom取了200当前总共拥有800元
Tom存了400当前总共拥有1200元
Tom取了200当前总共拥有1000元
Tom存了400当前总共拥有1400元
Tom存了400当前总共拥有1800元
Tom取了200当前总共拥有1600元
Tom取了200当前总共拥有1400元
Tom存了400当前总共拥有1800元
Tom存了400当前总共拥有2200元
Tom存了400当前总共拥有2600元
Tom存了400当前总共拥有3000元
最后Tom总共拥有3000元
        以下是使用tryLock()方法的交互，从之前知道，需要设置一个标志进行判断是否占用到了，如果占用到才能进行继续操作。同时需要捕获异常：
package person;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.*;
import java.util.concurrent.locks.Condition;;
public class Student {
	public int k=0;
	public int total;
	public int perMonth;
	public String name;
	Lock lock=new ReentrantLock();
	Condition condition=lock.newCondition();
	
	public void saveMoney(Student s) {
		// TODO Auto-generated method stub
		boolean locked=false;
		try
		{
			locked=lock.tryLock(1, TimeUnit.SECONDS);
			while(total>=3000)
			{
				try
				{
					condition.await();
				}
				catch(InterruptedException e)
				{
					e.printStackTrace();
				}
			}
			if(locked)
			{
				s.total=s.total+2*(s.perMonth);
				System.out.println(s.name+"存了"+2*s.perMonth+"当前总共拥有"+s.total+"元");
				condition.signal();
			}
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(locked)
			{
				lock.unlock();
			}
		}
			
		
		
		
	}
	public void getMoney(Student s)
	{
		boolean locked=false;
		try
		{
			locked=lock.tryLock(1, TimeUnit.SECONDS);
			while(s.total<=0)
			{
				try
				{
					condition.await();//使当前线程暂停，让出占用当前同步对象的锁，并进入等待状态
				}
				catch(InterruptedException e)
				{
					e.printStackTrace();
				}
			}
			if(locked)
			{
				s.total=s.total-s.perMonth;
				System.out.println(s.name+"取了"+s.perMonth+"当前总共拥有"+s.total+"元");	
				condition.signal();//唤醒那些暂停的线程，使其进入等待列表，类似于synchronized下的notify()方法
			}
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}
		finally
		{
			if(locked)
			{
				lock.unlock();
			}
		}
		


	}

}

运行测试程序，结果如下：

Tom最开始拥有1000元
Tom取了200当前总共拥有800元
Tom存了400当前总共拥有1200元
Tom存了400当前总共拥有1600元
Tom取了200当前总共拥有1400元
Tom取了200当前总共拥有1200元
Tom取了200当前总共拥有1000元
Tom取了200当前总共拥有800元
Tom取了200当前总共拥有600元
Tom取了200当前总共拥有400元
Tom取了200当前总共拥有200元
Tom存了400当前总共拥有600元
Tom取了200当前总共拥有400元
Tom存了400当前总共拥有800元
Tom存了400当前总共拥有1200元
Tom取了200当前总共拥有1000元
Tom存了400当前总共拥有1400元
Tom存了400当前总共拥有1800元
Tom存了400当前总共拥有2200元
Tom存了400当前总共拥有2600元
Tom存了400当前总共拥有3000元
最后Tom总共拥有3000元
        根据以上两种方法对应的交互方式，可以看出区别不大，但是也有不同之处：lock()不需要捕获异常，而tryLock()需要捕获异常；lock()不需要判别标志，而tryLock()需要判别标志。
Java：多线程中的Lock锁（未完待续）
weiweiqiao的专栏
01-11 641
在Java中，Lock是一个接口，它提供了比synchronized关键字更高级的线程同步机制。使用Lock接口可以创建更复杂和灵活的同步结构。Lock接口的常用实现类有ReentrantLock和ReentrantReadWriteLock，它们提供了可重入的互斥锁和读写锁。在需要进行同步的代码块中，通过调用`lock()`方法来获取锁。
Java多线程之Lock锁
weixin_45264992的博客
03-22 178
Java多线程之Lock锁 在我们学习synchronized之后，我们知道了两种办法对进程内对象加速，使得我们的数据安全，一个就是synchronized方法锁，这可以直接对一个方法进行同步，简单除暴，但是仅能获取方法造作的this对象的锁。而另一个就是synchronized代码块，可以对我们选中的代码进行同步，相比第一种，它可以操作不同的对象。 但相比与前两者，我现在要说的是另外一种，Lock锁。 Lock锁由我们手动开启和关闭，且Lock没有方法锁，只有代码块锁。 使用Lock锁，JVM将花费更少的
Java线程：线程的交互
weixin_34393428的博客
09-13 224
Java线程：线程的交互   SCJP5学习笔记   线程交互是比较复杂的问题，SCJP要求不很基础：给定一个场景，编写代码来恰当使用等待、通知和通知所有线程。   一、线程交互的基础知识   SCJP所要求的线程交互知识点需要从java.lang.Object的类的三个方法来学习：    void notify()           唤醒在此对象监视器上等待的单个线程。 ...
Java多线程之Lock的使用
zhangziyueup
12-21 325
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线程：线程交互
weixin_33830216的博客
12-27 138
一、基础知识 　　java.lang.Object的类的三个方法： 　　　　void notify():唤醒在此对象监视器上等待的单个线程。 　　　　void notifyAll():唤醒在此对象监视器上等待的所有线程。 　　　　void wait():导致当前线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法。 　　　　...
Java 多线程-Lock锁
刘伟佳的博客
03-05 316
Lock锁
java多线程实现大批量数据导入源码
09-29
在Java编程中，多线程技术是处理大数据批量导入或导出的重要手段。它能有效提升程序执行效率，尤其在数据库操作这样的I/O密集型任务中。本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量...
学习Java多线程之线程定义、状态和属性
09-02
因此，理解并掌握Java提供的synchronized关键字、wait/notify机制、Lock接口（如ReentrantLock）以及并发集合（如ConcurrentHashMap）等同步机制至关重要，它们可以帮助开发者编写出高效且安全的多线程代码。...
Java多线程-多线程相关概念
01-19
Java多线程技术是编程中不可或缺的一部分，它允许程序在同一时间执行多个任务，从而提高效率和响应速度。本文将深入探讨多线程相关的概念。 首先，我们要了解程序、进程和线程的区别。程序是一组指令的集合，静态...
基于Java JUC框架的售票系统与多线程锁通信设计源码
最新发布
09-30
本项目是一个基于Java JUC（Java并发包）框架构建的售票系统源码，它提供了深入学习和实践多线程编程的机会。...通过学习这个项目，开发者可以提高自己的并发编程技能，掌握Java JUC框架下多线程锁通信设计的精髓。
java多线程进度条
02-10
在Java编程中，多线程是一项关键特性，它允许程序同时执行多个任务，提升系统效率。在处理耗时操作如大文件下载、数据处理或网络请求时，展示进度条能够提供用户友好的交互体验，让使用者了解任务的完成状态。本主题...
Java多线程_Lock锁
LinJava-X的博客
06-28 198
Lock锁 JDK5.0版本开始，就提供更加强大的线程同步机制，通过显式定义同步锁对象来实现同步，同步锁使用Lock对象来充当 Lock接口控制多个线程对共享资源镜像访问的工具，锁提供了对共享资源的独占访问共享资源之前应先获得Lock对象 ReentrantLock类实现了Lock，它拥有与synchromized相同并性和内存语义，在实现线程安全的控制找那个，比较常用的是ReentrantLock，可以显式加锁，释放锁 经典用例1：没有加锁的情况，数字出现了相同的值。 public class TestL
JAVA- 锁机制介绍 线程锁
骑牛小道士
11-22 3398
JAVA基础-多线程锁机制
JAVA多线程之Lock
浮煌的博客
09-13 301
接口关系 　（1）Lock和ReadWriteLock是两大锁的根接口，Lock代表实现类是ReentrantLock（可重入锁），ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock。 　　　　Lock 接口支持那些语义不同（重入、公平等）的锁规则，可以在非阻塞式结构的上下文（包括 hand-over-hand 和锁重排算法）中使用这些规则。主要的实现是 ReentrantLock。 ReadWriteLock 接口以类似方式定义了一些读取者可以共享而写入
Java多线程-Lock锁
weixin_45203607的博客
10-03 691
Java多线程-Lock锁 介绍 在 jdk1.5 之后，并发包中新增了 Lock 接口(以及相关实现类)用来实现锁功能，Lock 接口提供了与 synchronized 关键字类似的同步功能，但需要在使用时手动获取锁和释放锁。 Lock 接口与synchronized关键字的区别 Lock 接口可以尝试非阻塞地获取锁 当前线程尝试获取锁。如果这一时刻锁没有被其他线程获取到，则成功获取并持有锁。 Lock 接口能被中断地获取锁 与 synchronized 不同，获取到锁的线程能够响应中断，当获取到的锁的线
[Java基础]线程同步之卖票案列分析
m0_51955470的博客
06-08 250
案列: 卖票。 需求: 某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票。 代码如下: package SellTicketPack; public class SellTicket implements Runnable{ private int tickets = 100; @Override public void run() { while (true) { if (tickets
Synchronized与lock_Allione_新浪博客
dsydly的博客
08-23 133
总结来说，Lock和synchronized有以下几点不同： ​1、ReentrantLock 拥有Synchronized相同的并发性和内存语义，此外还多了 锁投票，定时锁等候和中断锁等候。 线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定， 如果使用 synchronized ，如果A不释放，B将一直等下去，不能...
Java多线程中Lock的实现
大德如危的博客
06-25 416
在Java 1.5之后，并发包中新增了Lock接口用来实现锁功能，它提供了Synchronized关键字类似的功能，只是在使用时需要显式地获取锁和释放锁。虽然它缺少了隐式获取锁释放锁的便捷性，但是却拥有了锁释放和获取的可操作性、可中断地获取锁以及超时获取锁等多种选择。 1 Lock接口 Lock接口的主要api如下： 1）void lock()：获取锁，调用该方法的当前线程或获取锁，并从该方
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值