搞明白synchronized和ReetrantLock
上一篇文章,我们熟悉了Java锁的分类。今天,来学习下Java中常用的悲观锁synchronized和ReetrantLock吧。学习使我快乐,哦耶!
synchronized
synchronized是什么?
synchronized关键字可以保证,一段时间内共享资源只能被一个线程所使用,或者说一段代码一段时间内只能被一个线程执行,并且共享资源对其他线程是可见的。
实际上,synchronized就是,某个线程拿到一个锁,锁住共享资源,当使用完,放开锁,让其他线程申请锁并使用共享资源。
synchronized锁的级别
synchronized作用在普通方法或者代码片段上时,锁为对象本身。作用在static方法或者代码片段上时,锁为类本身。
synchronized的基本使用
我们设想一个卖票场景,有A、B两个售票窗口卖票,票池(共享资源)只有一个。
实验1
public class SellTicketRunnable implements Runnable {
// 剩余票数
static int ticket = 1000;
@Override
public void run() {
for (int i=0;i<550;i++){
sell();
}
}
// 买票操作
private synchronized void sell() {
System.out.println(Thread.currentThread().getName()+"开始卖票");
try {
// 模拟卖票
if (ticket <= 0){
System.out.println(Thread.currentThread().getName()+"窗口通知,票卖完了~");
}else {
Thread.sleep(5);
ticket--;
System.out.println(Thread.currentThread().getName()+"出票成功,现在还有"+ticket+"张票");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"结束卖票");
}
}
public static void main(String[] args) throws InterruptedException {
// 代码示例 1 基本使用
SellTicketRunnable sellTicketRunnable = new SellTicketRunnable();
Thread thread_1 = new Thread(sellTicketRunnable,"A窗口");
Thread thread_2 = new Thread(sellTicketRunnable,"B窗口");
thread_1.start();
thread_2.start();
thread_1.join();
thread_2.join();
System.out.println("运行结束,剩下"+SellTicketRunnable.ticket+"张票");
}
首先创建售票类SellTicketRunnable
,定义公告资源ticket
为1000张票,我们每个窗口模拟卖票550张,如果发现票卖完了,就系统提示,否则票数减1。main
方法开启两个线程,发现完美运行。发现票数最终为0,并且每个线程访问共享资源的时间内都是独享的。
A窗口开始卖票
A窗口窗口通知,票卖完了~
A窗口结束卖票
B窗口开始卖票
B窗口窗口通知,票卖完了~
B窗口结束卖票
运行结束,剩下0张票
synchronized对象级别的锁
刚才只生成了一个SellTicketRunnable
,只有一把锁。那我们生成两个SellTicketRunnable
对象,会不会有两把锁呢?
实验2
SellTicketRunnable sellTicketRunnable = new SellTicketRunnable();
SellTicketRunnable sellTicketRunnable_backups = new SellTicketRunnable();
Thread thread_1 = new Thread(sellTicketRunnable,"A窗口");
Thread thread_2 = new Thread(sellTicketRunnable_backups,"B窗口");
thread_1.start();
thread_2.start();
thread_1.join();
thread_2.join();
System.out.println("运行结束,剩下"+SellTicketRunnable.ticket+"张票");
// 运行结果如下:
A窗口开始卖票
B窗口开始卖票
A窗口出票成功,现在还有999张票
A窗口结束卖票
A窗口开始卖票
B窗口出票成功,现在还有998张票
B窗口结束卖票
B窗口开始卖票
A窗口出票成功,现在还有997张票
A窗口结束卖票
...
运行结束,剩下-1张票
将main
方法改成上边所示。首先,访问共享资源的时间不再独享。A窗口还没访问完数据库呢,B窗口就去访问了。这最终导致票可能超卖。(就剩1张票了,A、B窗口同时卖出,同时更新共享资源)。当然这段代码你多运行几次才会出现剩余-1
的情况,有时候可能为0
,毕竟那么巧的事,不是每次都遇到哈。说明,此时锁是对象级别的。
实际上,如果synchronized
作用在对象级别上。内存中,对象的对象头会记录当前获取锁的线程,利用的是Monitor
机制。
synchronized类级别的锁
实验3
public class SellTicketRunnablePlus implements Runnable {
// 剩余票数
static int ticket = 1000;
@Override
public void run() {
for (int i=0;i<550;i++){
sell();
}
}
public void sell() {
synchronized(SellTicketRunnablePlus.class){
System.out.println(Thread.currentThread().getName()+"开始卖票");
try {
// 模拟卖票
if (ticket <= 0){
System.out.println(Thread.currentThread().getName()+"窗口通知,票卖完了~");
}else {
Thread.sleep(5);
ticket--;
System.out.println(Thread.currentThread().getName()+"出票成功,现在还有"+ticket+"张票");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"结束卖票");
}
}
}
// 运行结果
A窗口开始卖票
A窗口窗口通知,票卖完了~
A窗口结束卖票
B窗口开始卖票
B窗口窗口通知,票卖完了~
B窗口结束卖票
运行结束,剩下0张票
将实验2主函数中的SellTicketRunnable
类换成SellTicketRunnablePlus
。SellTicketRunnablePlus
只是给sell
方法内部,synchronized
锁的是SellTicketRunnablePlus
类。此时又是一把锁了,所以两个窗口又可以某段时间内独享共享资源了。
synchronized是重入锁
synchronized可以保证不同线程同一时间只能有有一个独享共享资源,比如说线程1持有了锁,线程2去申请锁的时候,发现线程1持有锁呢,所以线程2需要等会(线程阻塞)。那么线程1在持有锁的情况下,可以再申请一把同样的锁吗?
实验4
public class ReentryTest {
public synchronized void outMethod(){
innerMethod();
System.out.println("这是外部方法,执行了");
}
private synchronized void innerMethod(){
System.out.println("这是内部方法,执行了");
}
}
// main方法
ReentryTest reentryTest = new ReentryTest();
reentryTest.outMethod();
//运行结果
这是内部方法,执行了
这是外部方法,执行了
当线程1执行outMethod
方法时,获得了锁。outMethod
调用innerMethod
方法时,线程1又去申请了同一把锁,发现申请成功了。可重入锁
是指同一个线程可以多次加同一把锁。
自JDK1.6开始,当只有两个线程竞争锁时,synchronized
是轻量级锁,超过两个线程竞争的时候是重量级锁。关于锁的分类,请戳链接: Java锁分类原来是这个样子。
ReetrantLock
synchronized
是关键字,很多操作都是隐式的,比如说释放锁
、自旋次数
等,都是虚拟机帮你搞定的。为了显示操作,并且拥有更强大的功能,ReetrantLock
来了。
ReetrantLock基本使用
实验5
ReentrantLock lock = new ReentrantLock();
lock.lock();
try{
// 业务逻辑
}catch (Exception e){
}finally {
lock.unlock();
}
ReetrantLock需要手动申请锁和释放锁,分别为方法lock
和unlock
。
ReetrantLock重入性
和synchronized
一样,ReetrantLock
也具备重入性。
实验6
ReentrantLock lock = new ReentrantLock();
int count = 0;
for (int i = 1; i <= 3; i++) {
lock.lock();
System.out.println("说明获取锁"+ ++count +"次");
}
for (int i = 1; i <= 3; i++) {
lock.unlock();
}
//
说明获取锁1次
说明获取锁2次
说明获取锁3次
公平锁和非公平锁
ReetrantLock
可以申请公平锁或者非公平锁(了解锁的分类:Java锁分类原来是这个样子)。
首先我们补充一个知识点,ReetrantLock
是实现AQS
机制的,就是说所有申请锁的线程,会被按需放到一个队列中,然后依次获取锁。公平锁
保证了,获取锁的顺序性。
实验7
//主函数
ReentrantLock lock = new ReentrantLock(true);
for (int i=1;i<=5;i++){
new Thread(new FairLockThread(lock),"第"+i+"个").start();
}
// FairLockThread类
public class FairLockThread implements Runnable {
ReentrantLock lock;
public FairLockThread(ReentrantLock lock) {
this.lock = lock;
}
@Override
public void run() {
for (int i = 1; i <= 2; i++) {
lock.lock();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "开始执行了");
System.out.println(Thread.currentThread().getName() + ":" + lock.getQueueLength());
lock.unlock();
}
}
}
// 结果
第1个开始执行了
第1个:4
第2个开始执行了
第2个:4
第3个开始执行了
第3个:4
第4个开始执行了
第4个:4
第5个开始执行了
第5个:4
第1个开始执行了
第1个:4
第2个开始执行了
第2个:3
第3个开始执行了
第3个:2
第4个开始执行了
第4个:1
第5个开始执行了
第5个:0
ReentrantLock
new的时候传入true
,就是申请了一把公平锁。FairLockThread
方法里面让一个线程执行两次申请锁、释放锁操作,并且模拟使用锁0.5秒。getQueueLength
方法就是查看,当前队列中阻塞的线程数。可以看出,锁的两遍申请是按照顺序的,从1~5。从线程是也可以看出,没有哪个线程可以偷偷的自己两边都执行完。
还是实验7
ReentrantLock lock = new ReentrantLock(false);
// 结果
第2个开始执行了
第2个:4
第2个开始执行了
第2个:4
第1个开始执行了
第1个:3
第1个开始执行了
第1个:3
第3个开始执行了
第3个:2
第4个开始执行了
第4个:2
第4个开始执行了
第4个:2
第5个开始执行了
第5个:1
第5个开始执行了
第5个:1
第3个开始执行了
第3个:0
我们只需要将主函数,newReentrantLock
的时候设置成false,此时申请的就是非公平锁了。再看运行结果,某个线程执行完第一遍,很大概率上就会执行第二遍。没有按照顺序执行,这是不公平的。
执行完一遍,然后紧接着执行第二遍,不用切换上下文,某线程一致使用CPU,这样效率更快的,所以非公平锁效率更高。
ReetrantLock可中断,预防死锁问题
试想一下,如果线程1已经持有锁1,现在想拿锁2,然后就可以开心的结束了。线程2已经持有锁2,现在想拿锁1,然后就可以开心的结束了。这俩线程还愉快的碰面了,结果谁都不放手,谁都不能愉快的结束,于是乎,死锁就产生了。
实验8
public class InterruptThread implements Runnable{
ReentrantLock firstLock;
ReentrantLock secondLock;
public InterruptThread(ReentrantLock firstLock, ReentrantLock secondLock) {
this.firstLock = firstLock;
this.secondLock = secondLock;
}
@Override
public void run() {
try {
firstLock.lock();
Thread.sleep(1000);
secondLock.lock();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
firstLock.unlock();
secondLock.unlock();
System.out.println(Thread.currentThread().getName()+"正常结束!");
}
}
}
// 主函数
ReentrantLock lock = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();
Thread a = new Thread(new InterruptThread(lock, lock2), "A");
Thread b = new Thread(new InterruptThread(lock2, lock), "B");
a.start();
b.start();
//结果
没有结果...
以上,运行到电脑死机也不会结束了。如果我们在主函数最后一行后面加上一行
a.interrupt();
运行结果,放个图吧。
可以看出,虽然A牺牲掉了,但是由于A的中断(放弃持有锁1)。B顺利完成了!为小A默哀一分钟。。。
相同与不同
相同
synchronized
和ReetrantLock
都是悲观锁、可重入锁。
不同
synchronized
是隐士申请、释放锁,虚拟机层面维护。ReetrantLock
是显示操作,代码维护。- 在JDK1.6之前,
synchronized
性能极差,1.6之后,它俩性能差不多。 ReetrantLock
可中断,避免死锁产生。ReetrantLock
可以申请公平锁
或者非公平锁
,可根据需求定制。
呜呼,从探索到验证,辣条君用了一天,小伙伴们点个赞再走吧。