多线程之进阶Lock替换掉synchronized--模拟多窗口共同卖票

最新推荐文章于 2023-01-01 06:16:40 发布
最新推荐文章于 2023-01-01 06:16:40 发布
阅读量336 收藏
点赞数
分类专栏： 多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cc907566076/article/details/83069038
版权

学习到Lock对象啦，用它替换掉synchronized之前两个小例子。
效果差不多的，不过他有Condition特有的功能，这里没有体现出来。主要看替换点，结合前面synchronized写法，很好理解。

package com.cc.sellticket3;

import java.util.concurrent.locks.ReentrantLock;
/*
 * 卖票服务
 */
public class TicketService {
	private ReentrantLock lock = new ReentrantLock();
	
	private int tickets = 50;

	public TicketService() {
		super();
	}

	public TicketService(int tickets) {
		super();
		this.tickets = tickets;
	}

	
	public void sellTickets() throws Exception {
		try {
			/*小测验-lock()方法比tryLock()快
			  if(lock.tryLock()) {
				if(tickets > 0) {
					tickets-- ;
					System.out.println(Thread.currentThread().getName()+"窗口卖了1张票，待卖票数："+tickets);
				}else {
					long time = System.currentTimeMillis() - TimeTools.getStartTime();
					throw new Exception(Thread.currentThread().getName()+"窗口：卖完了！  耗时：" + time + "毫秒！" );
				}
				tryLock 耗时：14112毫秒
				lock  	耗时：6302毫秒！

			}*/
			lock.lock();
			if(tickets > 0) {
				tickets-- ;
				System.out.println(Thread.currentThread().getName()+"窗口卖了1张票，待卖票数："+tickets);
			}else {
				long time = System.currentTimeMillis() - TimeTools.getStartTime();
				throw new Exception(Thread.currentThread().getName()+"窗口：卖完了！  耗时：" + time + "毫秒！" );
			}
		} catch (Exception e) {
			throw new Exception(e.getMessage());
		} finally {
			if(lock.isHeldByCurrentThread()) {
				lock.unlock();
			}
		}
	}
}


package com.cc.sellticket3;
/*
 * 记录开始时间工具
 */
public class TimeTools {
	private static long startTime = 0;

	public static long getStartTime() {
		return startTime;
	}
	public static void setStartTime(long startTime) {
		TimeTools.startTime = startTime;
	}
	
}

package com.cc.sellticket3;
/*
 * 多开几个窗口卖票
 */
public class SellTicketThread extends Thread{
	private TicketService service;

	public SellTicketThread(TicketService service) {
		super();
		this.service = service;
	}
	
	@Override
	public void run() {
		while(true) {
			try {
				Thread.sleep(300);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			try {
				service.sellTickets();
			} catch (Exception e) {
				System.err.println(e.getMessage());
				break;
			}
			
		}
	}

}


package com.cc.sellticket3;
/*
 * 模拟卖票运行
 */
public class Run {
	public static void main(String[] args) throws InterruptedException {
		//今天卖票服务一共卖80张票--一般50张
		TicketService service = new TicketService(80);
		//开始卖票时间
		TimeTools.setStartTime(System.currentTimeMillis());
		//卖票一直到结束
		SellTicketThread t1 = new SellTicketThread(service);
		t1.setName("1号");
		SellTicketThread t2 = new SellTicketThread(service);
		t2.setName("2号");
		SellTicketThread t3 = new SellTicketThread(service);
		t3.setName("3号");
		SellTicketThread t4 = new SellTicketThread(service);
		t4.setName("4号");
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

运行结果：
1号窗口卖了1张票，待卖票数：79
4号窗口卖了1张票，待卖票数：78
2号窗口卖了1张票，待卖票数：77
3号窗口卖了1张票，待卖票数：76
3号窗口卖了1张票，待卖票数：75
4号窗口卖了1张票，待卖票数：74
2号窗口卖了1张票，待卖票数：73
1号窗口卖了1张票，待卖票数：72
4号窗口卖了1张票，待卖票数：71
1号窗口卖了1张票，待卖票数：70
2号窗口卖了1张票，待卖票数：69
3号窗口卖了1张票，待卖票数：68
1号窗口卖了1张票，待卖票数：67
3号窗口卖了1张票，待卖票数：66
2号窗口卖了1张票，待卖票数：65
4号窗口卖了1张票，待卖票数：64
1号窗口卖了1张票，待卖票数：63
3号窗口卖了1张票，待卖票数：62
4号窗口卖了1张票，待卖票数：61
2号窗口卖了1张票，待卖票数：60
4号窗口卖了1张票，待卖票数：59
3号窗口卖了1张票，待卖票数：58
1号窗口卖了1张票，待卖票数：57
2号窗口卖了1张票，待卖票数：56
2号窗口卖了1张票，待卖票数：55
3号窗口卖了1张票，待卖票数：54
4号窗口卖了1张票，待卖票数：53
1号窗口卖了1张票，待卖票数：52
2号窗口卖了1张票，待卖票数：51
3号窗口卖了1张票，待卖票数：50
1号窗口卖了1张票，待卖票数：49
4号窗口卖了1张票，待卖票数：48
2号窗口卖了1张票，待卖票数：47
3号窗口卖了1张票，待卖票数：46
4号窗口卖了1张票，待卖票数：45
1号窗口卖了1张票，待卖票数：44
4号窗口卖了1张票，待卖票数：43
2号窗口卖了1张票，待卖票数：42
1号窗口卖了1张票，待卖票数：41
3号窗口卖了1张票，待卖票数：40
3号窗口卖了1张票，待卖票数：39
1号窗口卖了1张票，待卖票数：38
2号窗口卖了1张票，待卖票数：37
4号窗口卖了1张票，待卖票数：36
2号窗口卖了1张票，待卖票数：35
3号窗口卖了1张票，待卖票数：34
4号窗口卖了1张票，待卖票数：33
1号窗口卖了1张票，待卖票数：32
1号窗口卖了1张票，待卖票数：31
3号窗口卖了1张票，待卖票数：30
2号窗口卖了1张票，待卖票数：29
4号窗口卖了1张票，待卖票数：28
2号窗口卖了1张票，待卖票数：27
3号窗口卖了1张票，待卖票数：26
1号窗口卖了1张票，待卖票数：25
4号窗口卖了1张票，待卖票数：24
2号窗口卖了1张票，待卖票数：23
3号窗口卖了1张票，待卖票数：22
4号窗口卖了1张票，待卖票数：21
1号窗口卖了1张票，待卖票数：20
2号窗口卖了1张票，待卖票数：19
4号窗口卖了1张票，待卖票数：18
3号窗口卖了1张票，待卖票数：17
1号窗口卖了1张票，待卖票数：16
2号窗口卖了1张票，待卖票数：15
3号窗口卖了1张票，待卖票数：14
1号窗口卖了1张票，待卖票数：13
4号窗口卖了1张票，待卖票数：12
2号窗口卖了1张票，待卖票数：11
3号窗口卖了1张票，待卖票数：10
1号窗口卖了1张票，待卖票数：9
4号窗口卖了1张票，待卖票数：8
2号窗口卖了1张票，待卖票数：7
1号窗口卖了1张票，待卖票数：6
4号窗口卖了1张票，待卖票数：5
3号窗口卖了1张票，待卖票数：4
2号窗口卖了1张票，待卖票数：3
3号窗口卖了1张票，待卖票数：2
4号窗口卖了1张票，待卖票数：1
1号窗口卖了1张票，待卖票数：0
3号窗口：卖完了！ 耗时：6302毫秒！
4号窗口：卖完了！ 耗时：6302毫秒！
2号窗口：卖完了！ 耗时：6302毫秒！
1号窗口：卖完了！ 耗时：6302毫秒！

知识点：
ReentrantLock类的lock()和unlock()方法控制对象锁。

cc-lady
关注
专栏目录
我的Android进阶之旅------>Android基于HTTP协议的多线程断点下载器的实现
字节卷动
08-20 8130
我的Android进阶之旅------>Android基于HTTP协议的多线程断点下载器的实现，实现了多线程下载和断点下载 1.多线程下载的原理 注意：由于Android移动设备和PC机的处理器还是不能相比，所以开辟的子线程建议不要多于5条。当然现在某些高端机子的处理器能力比较强了，就可以多开辟几条子线程。 2、为了实现断点下载，采用数据库方式记录下载的进度，这样当你将该应用退出后，下次点击下载的时候，程序会去查看该下载链接是否存在下载记录，如果存在下载记录就会判断下载的进
多线程之进阶Lock替换掉synchronized--练习生产者消费者模型
CC-lady的博客
10-16 372
学习到Lock对象啦，用它替换掉synchronized之前两个小例子。 这里等待/唤醒模式，用了Conditon。结合之前的生产者消费者例子，很好理解。 其他类不变，只替换掉MyStack类： package com.cc.p_c_stack_mutiList2; import java.util.ArrayList; import java.util.List; import java.ut...
如何使用Lock取代synchronized
qianfeng_dashuju的博客
06-14 466
　　如何使用Lock取代synchronized　　在多线程中，1.5版本之前，我们都使用同步代码块或者同步方法来解决线程安全问题　　比如：　　同步代码块　　synchronized(锁对象){　　功能代码;　　}　　同步方法　　public synchronized void test(){　　功能代码;　　}　　在1.5版本，在java的工具类包中，java.util.concurrent.l...
重入锁 （替换synchronized）
zwrefine的博客
08-13 342
package com.brendan.cn.concurrent;import java.util.concurrent.locks.ReentrantLock;public class ReenterLock implements Runnable { public static ReentrantLock lock = new ReentrantLock(); public s
ReentrantLock代替synchronized
coderchem的博客
07-22 379
1、ReentrantLock是手工锁，锁住的是ReentrantLock对象，synchronized是自动锁，会自动释放锁，锁住的是堆内存中的对象。synchronized，在代码遇到异常的时候，JVM会自动释放锁。ReentrantLock则不会。 /** * ReentrantLock替代synchronized */ public class ReentrantLock2 { ...
使用原子类替代synchronized和Lock(重量级锁)
Xiaofeng_Lu__的博客
01-01 419
我们都知道，synchronized和Lock是比较重量级的锁，多线程进行操作时，会锁住一段代码，这样高并发下效率就比较低。而juc提供了原子类和volatile，就是解决重量级锁的效率问题，原子类会调用native方法，native方法调用操作系统的接口（汇编指令：cmpxchg），在硬件层面对变量进行加锁，这种细粒度的锁，效率更高。而volatile保证了多线程之间变量的可见性，修改变量后立即写回到主存并让其他线程可见。
线程同步Synchronized，监视器monitor和锁lock的关系2---马克-to-win java视频
06-10
线程同步Synchronized，监视器monitor和锁lock的关系2---马克-to-win java视频
多线程实现四个窗口一起卖票（synchronized）
qq_43302785的博客
12-18 4148
如果不加synchronized（）同步锁，则会出现两个窗口卖了一张票 多线程的类 代码如下 public class SellTicktDemo implements Runnable { //定义总票数 private int total =100; //定义编号 private int no = total+1; //定义线程同步对象 private Object object = new ...
Java 多线程与并发(4-26)-关键字- synchronized详解.pdf
最新发布
07-21
"Java 多线程与并发(4-26)-关键字- synchronized详解" Java 多线程与并发中的 synchronized 关键字是实现同步块的互斥访问和线程的阻塞及唤醒等工作的重要工具。下面将对 synchronized 关键字进行详细分析。 ...
Java多线程窗口售票问题实例
08-28
Java多线程窗口售票问题实例 Java多线程窗口售票问题实例是Java多...通过这两个示例，我们可以看到，使用synchronized关键字和lock()、unlock()方法可以有效地解决多线程之间的同步问题，确保每张票只能被售出一次。
Java多线程中Lock的使用
weixin_30439031的博客
04-07 66
Jdk1.5以后，在java.util.concurrent.locks包下，有一组实现线程同步的接口和类，说到线程的同步，可能大家都会想到synchronized关键字， 这是java内置的关键字，用来处理线程同步的，但这个关键字有很多的缺陷，使用起来也不是很方便和直观，所以就出现了Lock，下面，我们 就来对比着讲解Lock。 通常我们在使用synchronized关键字的时候会遇到下面...
使用Lock实现互斥（synchronized的一个替代)
u012866553的博客
12-06 505
传说有一本江湖罕见的武功秘籍，该书珍藏在主持大师手中。一天大师盛情邀请江湖好汉前来观摩该书，但是一次只能有一个人来看。 该怎么办呢？用synchronized来实现吗？都用臭了，算了。用下李狗(Doug Lea)写的Lock吧。 实现很简单，首先获得一个锁实例  Lock lock = new ReentrantLock(); 接着获得一把锁: lock.lock()
Java的高并发编程系列（五）reentrantlock替换synchronized
N-SOKACH的博客
03-29 513
java高并发编程主要有下面三个组成： 1.同步器synchronized 2.同步容器 3.线程池：threadPool、executort 本例中由于test1锁定this，只有test1执行完毕的时候,test2才能执行： public class ReentrantLock1 { public synchronized void test1(){ fo...
利用lock实现多线程同步
shizhan1881的专栏
06-03 7638
我们不仅可以使用synchronized来实现多线程同步，还可以通过创建锁对象来实现多线程的同步，还是上次模拟取现的操作，这次利用lock对象实现同步，下面是代码：     import java.util.concurrent.locks.ReentrantLock; public class TestSyn { public static void main(String[]
性能优化——Lock 同步锁的优化方法
qq_36589864的博客
08-21 308
在 JDK1.5 之后，Java 还提供了 Lock 同步锁。那么它有什么优势呢？ 相对于需要 JVM 隐式获取和释放锁的 Synchronized 同步锁，Lock 同步锁（以下简称 Lock 锁）需要的是显示获取和释放锁，这就为获取和释放锁提供了更多的灵活性。Lock 锁的基本操作是通过乐观锁来实现的，但由于 Lock 锁也会在阻塞时被挂起，因此它依然属于悲观锁。我们可以通过一张图来简单对比下两个同步锁，了解下各自的特点： 从性能方面上来说，在并发量不高、竞争不激烈的情况下...
多线程卖票问题（ReentrantLock的使用）
blindore的博客
07-01 169
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** Description @Author blindore @Date Created in 2021-7-1 9:59 @Version 2.10.6 */ public class TestLock { public static void main(String[] args) { Tickets td
多线程售票（用synchronized锁、ReentrantLock锁解决多线程数据安全问题）
weixin_51914192的博客
11-30 542
标题（多个）三个线程售票100或者更（少）多（线程安全问题） 创建售票类SellTicket并继承Runnable接口 使用synchronized锁 public class SellTicket implements Runnable{ private int tickets=100;//定义成员变量 有一百张票 private Object obj=new Object();//创建对象锁 @Override public void run() {
java多线程并发之synchronized
文哥
03-29 621
一、前言javase还是在大一时候学的了，后来学习android、j2ee等等。现在回想起来发现自己基础还是不是太牢，因此准备花一些时间来回顾一些java基础知识。就准备从多线程出发。二 多线程并发多线程在我们实际项目中应用中还是比较多的，比如在Android中我们不可以在主线程刷新UI，因此必须创建子线程，而创建线程又是一个耗费资源的操作，因此我们需要加以控制，即线程池。不过本篇博客不介绍线程池方
Lock锁-用Lock完成三窗口卖票
qq_45162113的博客
01-27 206
Lock锁 从JDK5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步，同步锁使用Lock对象充当 java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象 ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在现实线程安全的控制中，比较常用的是ReentrantLoc
Java多线程Lock与synchronized对比分析
"Java多线程之Lock的总结与比较" 在Java多线程编程中，Lock接口提供了比`synchronized`关键字更为灵活的锁机制。Lock接口定义在`java.util.concurrent.locks`包中，其核心功能是允许程序员更精确地控制线程的同步。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值