多线程-MyLock实现

最新推荐文章于 2024-10-11 16:11:05 发布
最新推荐文章于 2024-10-11 16:11:05 发布
阅读量1.3k 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： 多线程 文章标签： 重入锁 Lock实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yanghw117/article/details/81349259
博客探讨了在多线程环境下计数器存在的线程问题，并通过自定义的MyLock来解决这一问题。展示了未使用MyLock时的混乱输出，以及使用MyLock后的有序输出，证明了MyLock的线程安全性。还讨论了MyLock的可重入性，并进行了相应的改进。

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

1、计数器线程问题

import java.util.Random;

public class Sequence {

	private int value;

	public int getNext() {
		return value++;
	}

	// 测试
	public static void main(String[] args) {
		Sequence seq = new Sequence();
		// 创建多个线程
		for (int i = 0; i < 3; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					while (true) {
						System.out.println(Thread.currentThread().getName() + "===" + seq.getNext());
						try {
							Thread.sleep(50 * (new Random().nextInt(5) + 1));
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				}

			}).start();
		}
	}

}

运行结果：

Thread-0===0
Thread-1===1
Thread-2===2
Thread-1===3
Thread-0===4
Thread-1===5
Thread-1===7
Thread-2===8
Thread-0===6
Thread-2===9
Thread-1===11
Thread-2===10
Thread-0===12
Thread-1===13
Thread-0===14
Thread-2===15
Thread-0===16
Thread-1===17
Thread-0===18
Thread-1===19
Thread-2===19
Thread-0===20
Thread-1===22
Thread-0===21
Thread-2===23
Thread-1===24
Thread-0===25
Thread-2===26
Thread-1===27
Thread-2===28
Thread-1===29
Thread-0===30
Thread-1===32
Thread-2===31
Thread-1===33
Thread-0===34
Thread-0===35
Thread-0===36
Thread-1===37
Thread-2===36
Thread-1===38
Thread-0===39
Thread-1===40
Thread-0===41
Thread-2===42
Thread-1===43
Thread-2===44
Thread-1===45
Thread-2===46
Thread-0===47
Thread-2===48
Thread-1===49
Thread-0===50
Thread-2===51
Thread-1===52
Thread-2===53
Thread-0===54
Thread-2===54
Thread-1===55
Thread-2===56
Thread-0===57
Thread-0===58
Thread-2===59
Thread-1===58
Thread-1===60
Thread-0===61
Thread-2===62
Thread-1===63
Thread-0===64
2、通过自己实现的锁来解决计数器的线程安全问题

计数器代码改写：

import java.util.Random;

public class Sequence {

	private int value;
	
	private MyLock lock;

	public int getNext() {
		lock.lock();
		int result = value++;
		lock.unlock();
		return result;
	}

	// 测试
	public static void main(String[] args) {
		Sequence seq = new Sequence();
		// 创建多个线程
		for (int i = 0; i < 3; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					while (true) {
						System.out.println(Thread.currentThread().getName() + "===" + seq.getNext());
						try {
							Thread.sleep(50 * (new Random().nextInt(5) + 1));
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				}

			}).start();
		}
	}

}

MyLock实现：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class MyLock implements Lock {
	
	private boolean isLocked = false;//获取锁的状态

	@Override
	public synchronized void lock() {
		while(isLocked)
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		isLocked = true;//第一个进来线程拿到锁，改变锁状态
	}
	
	@Override
	public synchronized void unlock() {
		if(isLocked){//当前状态为锁定状态才可释放锁
			isLocked = false;
			notify();//唤醒等待获得锁的线程
		} else {
			throw new IllegalStateException("please get lock first!");
		}
	}

	@Override
	public void lockInterruptibly() throws InterruptedException {
		// TODO Auto-generated method stub
		
	}

	@Override
	public boolean tryLock() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public Condition newCondition() {
		// TODO Auto-generated method stub
		return null;
	}

}

运行结果：

Thread-0===0
Thread-1===2
Thread-2===1
Thread-1===3
Thread-1===4
Thread-0===5
Thread-0===6
Thread-2===7
Thread-1===8
Thread-2===9
Thread-0===10
Thread-2===11
Thread-1===12
Thread-1===13
Thread-0===14
Thread-1===15
Thread-2===16
Thread-0===17
Thread-2===18
Thread-2===19
Thread-1===20
Thread-2===21
Thread-0===22
Thread-2===23
Thread-1===24
Thread-0===25
Thread-2===26
Thread-1===27
Thread-0===28
Thread-2===29
Thread-1===30
Thread-2===31
Thread-0===32
Thread-2===33
Thread-1===34
Thread-0===35
Thread-2===36
Thread-0===37
Thread-1===38
Thread-0===39
Thread-1===40
Thread-2===41
Thread-1===42
Thread-2===43
Thread-0===44
Thread-2===45
Thread-0===46
Thread-1===47
Thread-2===48
Thread-0===49
Thread-1===50
Thread-2===51
Thread-2===52
Thread-0===53
Thread-1===54
Thread-0===55
Thread-2===56
Thread-0===57
Thread-2===58
Thread-1===59
Thread-1===60
Thread-0===61
Thread-0===62
Thread-2===63
Thread-1===64
Thread-1===65
Thread-2===66
Thread-1===67
Thread-0===68
Thread-2===69
Thread-2===70
Thread-0===71
Thread-1===72
Thread-0===73
Thread-2===74
Thread-1===75
Thread-1===76
Thread-0===77
Thread-0===78
Thread-2===79
Thread-1===80
Thread-2===81
Thread-0===82
Thread-2===83
Thread-1===84
Thread-1===85
Thread-0===86
Thread-2===87
Thread-2===88
Thread-1===89
Thread-0===90
Thread-2===91
Thread-1===92
Thread-0===93
Thread-0===94
Thread-2===95
Thread-0===96
Thread-1===97
Thread-2===98
Thread-2===99
Thread-1===100
Thread-2===101
Thread-0===102
Thread-2===103
Thread-1===104
Thread-0===105
Thread-2===106
Thread-1===107
Thread-0===108
Thread-0===109
Thread-2===110
Thread-1===111
Thread-0===112
Thread-1===113
Thread-0===114
Thread-2===115
Thread-1===116
Thread-0===117
Thread-2===118
Thread-1===119
Thread-0===120
Thread-2===121
Thread-1===122
Thread-0===123
Thread-0===124
Thread-0===125
3、MyLock是否可重入?


public class MyLockReentrant {
	
	private MyLock lock = new MyLock();
	
	public void a(){
		lock.lock();
		System.err.println("a");
		b();
		lock.unlock();
	}
	
	public void b(){
		lock.lock();
		System.err.println("b");
		lock.unlock();
	}
	
	public static void main(String[] args) {
		MyLockReentrant lockReentrant = new MyLockReentrant();
		lockReentrant.a();
	}
}

运行结果：

线程发生无限期阻塞，说明MyLock不可重入，接下来对MyLock进行改进

4、MyLock改进为可重入

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class MyLock implements Lock {
	
	private boolean isLocked = false;//获取锁的状态
	
	private Thread lockThread;//当前获得锁的线程
	
	private int lockCount;//获得锁次数

	@Override
	public synchronized void lock() {
		while(isLocked && lockThread != Thread.currentThread())
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		isLocked = true;//第一个进来线程拿到锁，改变锁状态
		lockThread = Thread.currentThread();
		lockCount++;
	}
	
	@Override
	public synchronized void unlock() {
		if(isLocked){//当前状态为锁定状态才可释放锁
			if(lockThread == Thread.currentThread()){
				lockCount--;
				if(lockCount == 0){
					isLocked = false;
					notify();//唤醒等待获得锁的线程
				}
			} 
		} else {
			throw new IllegalStateException("please get lock first!");
		}
	}

	@Override
	public void lockInterruptibly() throws InterruptedException {
		// TODO Auto-generated method stub
		
	}

	@Override
	public boolean tryLock() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public Condition newCondition() {
		// TODO Auto-generated method stub
		return null;
	}

}

运行结果：

多线程之lock详解
qq_39497281的博客
08-16 1373
多线程锁的使用，包括lock和ReadWriteLock
【Java难点】多线程-终极
我爱写代码 我爱写代码 我爱写代码
07-31 445
JMM(Java内存模型Java Memory Model，简称JMM)本身是一种抽象的概念并不真实存在它仅仅描述的是一组定或规范，通过这组规范定义了程序中(尤其是多线程)各个变量的读写访问方式，并决定一个线程对共享变量的写入何时可用，以及如何变成对另一个线程可见，关键技术点都是围绕多线程的原子性可见性和有序性展开的。添加volatile关键字后，JVM为什么会加入内存屏障？
多线程中的Lock小结
weixin_34174105的博客
03-09 122
1.lock和synchronized的区别 1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问； 2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程...
多线程-锁（Lock）
Artisan_w
06-09 407
锁的分类 1，公平锁/非公平锁 公平锁是指线程按照申请顺序获得锁。如果休眠队列上有线程了，那新进入的竞争线程一定要在休眠队列上排队。 非公平锁是指线程能够无视休眠队列，直接竞争锁，使后申请的线程可能先占有锁。可能会导致优先级反转或者饥饿现象。非公平锁的优点在于吞吐量比公平锁大。 对于Java ReetrantLock而言，通过构造函数指定该锁是公平锁，默认是非公平锁。 2，可重入锁 又名递归锁。是指在同一个线程在外层方法获取锁的时候，进入内层会自动获取锁，sychronized和Java ReetrantL
多线程_Lock
每天做最好的自己
04-12 160
ReentrantLock和synchronized区别 作用跟synchronized 锁一样 reentrantlock 底层是 cas (值,期望,预期) synchronized 底层锁升级 reentrantlock 可以tryLock 尝试锁 a. 如果在某时间段内获取到锁,就执行 b. 如果拿不到锁,不需要跟synchronized一样wait,可以直接跳过,继续执行代码 需要...
多线程（Lock锁）
Amory的博客
05-07 1182
多线程（Lock锁） Lock锁 JDK1.5推出的新一代线程同步方式，更强大、更灵活、效率也更高。 lock() lock()方法是平常使用得最多的一个方法，如果采用Lock，必须主动去释放锁，在发生异常时，不会自动释放锁。所以使用Lock必须在try catch中进行，并且将释放锁的操作放在finally中，防止死锁。 l.lock(); try { }catch(Exception e){ e.print... }finally { l.unlock(); try
50 C++ 多线程 ------ 多个线程共享资源问题fix方案二 ----- lock_guard类，unique_lock 类
hunandede的博客
01-15 408
在上一节中，我们使用了mutex的lock函数和unlock函数处理共享资源问题这一节，我们学习使用 lock_guard来处理 共享资源问题。
【Java难点】多线程-终极【更新中...】
我爱写代码 我爱写代码 我爱写代码
05-11 2027
JMM(Java内存模型Java Memory Model，简称JMM)本身是一种抽象的概念并不真实存在它仅仅描述的是一组定或规范，通过这组规范定义了程序中(尤其是多线程)各个变量的读写访问方式，并决定一个线程对共享变量的写入何时可用，以及如何变成对另一个线程可见，关键技术点都是围绕多线程的原子性可见性和有序性展开的。添加volatile关键字后，JVM为什么会加入内存屏障？
linux-多线程--面试题
热门推荐
雨夜聆风的专栏
05-21 1万+
刚无意中看到MoreWindows博主秒杀多线程面试题（http://blog.youkuaiyun.com/column/details/killthreadseries.html），第一篇就有他收集的面试题。那我就用来检验一下自己学的怎么样吧。     前面的选择题那些跳过，直接看最后的编程题。 第三题（某培训机构的练习题）： 子线程循环 10 次，接着主线程循环 100 次，接着又回到子线
多线程实现多窗口买票
qq_32521381的博客
04-30 732
需求：多个窗口同时开始买票 方案一： class Ticket extends Thread { private static int num = 100; Ticket(String name) { super(name); } public void run() { while(num>0) { ...
my_lock-开源
07-16
my_lock 是 Epitech 计算机科学学校中使用的 session locker 的一个分支。 我用 C++ 编写它并使用 Xlib。
【Java多线程】——Lock的应用
名侦探张六儿的博客
05-21 541
    在java多线程编程中，很多时候我们会使用synchronized关键字来实现线程之间的同步执行，并通过wait／notify机制实现线程之间的通信。JDK1.5中增加了ReentrantLock类也可以实现synchronized关键字相同的效果，并且使用Condition类可以实现类似于wait／notify一样的线程之间的通信。一、使用ReentrantLock实现同步效果    在...
011.多线程-lock锁
行者常至
11-16 315
package cn.qbz.thread; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * @Author: 花生米 * @Date: 2018/11/15 ...
Java多线程之Lock深入理解
上善若泪
12-25 2093
文章目录1 Lock原理深入理解1.1 synchronized的缺陷1.2 java.util.concurrent.locks包下常用的类1.2.1 Lock接口1.2.1.1 lock方法1.2.1.2 tryLock方法1.2.1.3 lockInterruptibly方法1.2.1.4 newCondition方法1.2.2 ReentrantLock1.2.2.1 可重入锁概念1.2.2.2 ReentrantLock使用1.2.2.2.1 lock用法1.2.2.2.2 tryLock用法1.
多线程线程锁的概念和介绍
最新发布
Jay的小提琴的博客
10-11 1363
在多线程环境下，为了让多线程安全地访问和使用共享变量，必须引入锁机制。锁机制即当一个线程持有锁后，其他线程只能进行等待，直到持有锁的线程释放锁，再次重新竞争锁。
线程锁Lock
qq_45611346的博客
02-21 677
线程锁Lock 使用相较于synchronized更加灵活，在jdk5时性能比synchronized要好 在jdk7后，synchronized也升级了，单用性能上差不多(快慢)，功能上lock更多 LOCK是接口 void lock():获取锁，如锁被占用则等待 相当于排队 boolean trylock():获取锁，获取成功返回true 相当于排号 void unlock()：释放锁 实现类： ​ 一、重入锁：ReentrantLock，与synchronized一样具有互斥锁功能 ​ Lock
多线程学习三：Synchrounized与lock的一些点
dulixing0154084的博客
11-09 240
一个对象只有一个对象锁，当一个线程获取该对象的对象锁后，其他线程就无法在获取此对象的对象锁。 当程序异常时，对于synchronized方法或者synchronized代码块，jvm会自动释放当前线程所占用的锁，所以不存在由异常引发的死锁现象。 Synchrounized和lock都能实现同步访问，Synchrounized属于java的内置关键字，执行完成后系统会自动使线程释放对象锁，而loc...
java自己实现一个lock锁
清缘幽梦
02-01 377
package com.dinglit.lock; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Loc...
【数据结构】C语言实现链表（单链表部分）
m0_74459723的博客
01-02 701
链表的单个节点由数据域跟指针域构成，节点中指针域所存储的指针就是下一个节点的地址。这里有一点需要注意，next的指针类型是，不是SLTNode*。{}SLTNode;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值