详解synchronized锁的各种用法及注意事项
1 前言
本文主要通过简单的demo
来阐述synchronized
锁的各种用法以及使用synchronized
锁的相关注意事项,记录下来同时也方便自己记忆。
synchronized
锁是jvm内置的锁,不同于ReentrantLock
锁。synchronized
关键字可以修饰方法,也可以修饰代码块。synchronized
关键字修饰方法时可以修饰静态方法,也可以修饰非静态方法;同样,synchronized
关键字修饰代码块时可以修饰对象,也可以修饰类。当然,synchronized
修饰静态方法/类和非静态方法/对象时的作用范围是不同的。下面通过各种demo
来详解synchronized
的各种用法及注意事项。
2 synchronized类锁
这里所说的synchronized
类锁的作用范围是类级别的,不会因为同一个类的不同对象执行而失效。
2.1 synchronized修饰同一个类的两个静态方法时互斥
public class SynchronizeAndClassLock {public static void main(String[] args) throws Exception {new Thread(() -> {// new了一个ClassLock对象new ClassLock().test1();}).start();new Thread(() -> {// new了另一个ClassLock对象new ClassLock().test2();}).start();}}
class ClassLock {public synchronized static void test1(){System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}// 【注意】public static void test2(){ 不会互斥,因为此时test2没有使用类锁。public synchronized static void test2(){System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}
}
运行结果:
【结论】两个线程分别同时执行同一个类产生的不同对象的两个不同 synchronized static
方法,类锁生效,虽然是不同对象,因为两个线程使用的是同一个类锁。反过来,假如test2
方法没有synchronized
修饰的话,只有test1
方法有被synchronized
修饰,此时两个方法也不会互斥,一个有锁,一个没有锁,自然不会互斥。
2.2 synchronized分别修饰同一个类的静态方法和当前类时互斥
public class SynchronizeAndClassLock2 {public static void main(String[] args) throws Exception {new Thread(() -> {// new了一个ClassLock2对象new ClassLock2().test1();// ClassLock2.test1();}).start();new Thread(() -> {// new了另一个ClassLock2对象new ClassLock2().test2();// ClassLock2.test2();}).start();}}
class ClassLock2 {public synchronized static void test1(){System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}public static void test2(){// 【注意】synchronized (SynchronizeAndClassLock2.class)不会互斥synchronized (ClassLock2.class) {System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}}
}
运行结果:
【结论】两个线程同时分别执行一个被synchronized修饰static方法,一个有synchnized(该类)代码块的static方法,锁生效,虽然是不同对象,因为两个线程使用的同一个类锁。反过来,如果是修饰的不同类,因为类锁不同,肯定不会互斥,比如将test2
方法的synchronized (ClassLock2.class)
这句代码改成synchronized (SynchronizeAndClassLock2.class)
,此时不会互斥。
2.3 synchronized分别修饰同一个静态对象时互斥
public class SynchronizeAndClassLock10 {public static void main(String[] args) throws Exception {new Thread(() -> {new RunObject1().test1();}).start();new Thread(() -> {new RunObject2().test2();}).start();}
}class RunObject1 {public static void test1(){// 【1】synchronized (StaticLock2.staticLock1) {synchronized (StaticLock2.staticLock) {System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}}
}class RunObject2 {public static void test2() {// 【2】synchronized (StaticLock2.staticLock2) {synchronized (StaticLock2.staticLock) {System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}}
}class StaticLock2 {public static Object staticLock = new Object();
}
运行结果:
【结论】synchronized
分别修饰同一个类的静态对象时互斥,反过来,如果是修饰不同的静态对象,肯定不会互斥,比如将上面代码中标【1】
和【2】
的synchronized
代码结合使用。
3 synchronized对象锁
这里说的synchronized
对象锁的作用范围是对象级别的即仅仅作用于同一个对象,如果是同一个类的两个不同的对象是不会互斥的,即没有效果的。
3.1 synchronized修饰同一个类对象的两个非静态方法时互斥
public class SynchronizeAndObjectLock2 {public static void main(String[] args) throws Exception {// 【注意】当且仅当是同一个SynchronizeAndObjectLock2对象SynchronizeAndObjectLock2 synchronizeAndObjectLock2 = new SynchronizeAndObjectLock2();new Thread(() -> {synchronizeAndObjectLock2.test1();}).start();new Thread(() -> {synchronizeAndObjectLock2.test2();}).start();}public synchronized void test1(){System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}public synchronized void test2(){System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}
}
运行结果:
【结论】两个线程同时执行被synchronized
修饰的相同对象的不同(相同)方法,锁生效,因为两个线程使用的是相同的对象锁
3.2 synchronized分别修饰同一个类对象的非静态方法和当前对象时互斥
public class SynchronizeAndObjectLock3 {public static void main(String[] args) throws Exception {// 【注意】当且仅当是同一个SynchronizeAndObjectLock3对象SynchronizeAndObjectLock3 synchronizeAndObjectLock3 = new SynchronizeAndObjectLock3();new Thread(() -> {synchronizeAndObjectLock3.test1();}).start();new Thread(() -> {synchronizeAndObjectLock3.test2();}).start();}public void test1(){synchronized(this) {System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}}public synchronized void test2(){System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}
}
运行结果:
【结论】snchronized
修饰非静态方法与synchronized(this)
互斥,可见,snchronized
修饰非静态方法实质锁的是当前对象。
3.3 synchronized修饰不同对象的两个非静态方法时不会互斥
public class SynchronizeAndObjectLock {public static void main(String[] args) throws Exception {new Thread(() -> {// 这里new 了一个SynchronizeAndObjectLock对象new SynchronizeAndObjectLock().test1();}).start();new Thread(() -> {// 这里new 了另一个SynchronizeAndObjectLock对象new SynchronizeAndObjectLock().test2();}).start();}public synchronized void test1(){System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}public synchronized void test2(){System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}
}
运行结果:
【结论】两个线程同时执行被synchronized
修饰的不同对象的不同(相同)方法,锁未生效,因为两个线程使用的是不同的对象锁。
3.4 synchronized代码块修饰同一个对象时互斥
public class SynchronizeAndObjectLock5 {private Object objectLock = new Object();public static void main(String[] args) throws Exception {SynchronizeAndObjectLock5 synchronizeAndObjectLock5 = new SynchronizeAndObjectLock5();new Thread(() -> {synchronizeAndObjectLock5.test1();}).start();new Thread(() -> {synchronizeAndObjectLock5.test2();}).start();}public void test1(){synchronized(objectLock) {System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}}public void test2(){synchronized(objectLock) {System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}}
}
运行结果:
【结论】synchronized
代码块修饰同一个对象时互斥,若synchronized
代码块修饰的是不同对象,那么不会互斥。
4 synchronized修饰当前类和当前对象时不会互斥
public class ClassAndObjectLock {public static void main(String[] args) throws Exception {new Thread(() -> {ClassAndObjectLock.test1();}).start();new Thread(() -> {new ClassAndObjectLock().test2();}).start();}public static void test1(){synchronized (ClassAndObjectLock.class) {System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}}public void test2(){synchronized (this) {System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {}System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");}}
}
运行结果:
【结论】可见,类锁和对象锁是相互独立的,互不相斥。
5 synchronized锁注意事项
5.1 synchronized锁不能被中断
为了模拟synchronized
锁不可中断,下面先让两个线程进入死锁,然后再用main
线程去中断其中一个线程,看被中断的线程能否释放锁并被唤醒。
public class DeadLockCannotInterruptDemo {private static Object lock1 = new Object();private static Object lock2 = new Object();public static void main(String[] args) throws Exception {Thread threadA = new Thread(new Runnable() {@Overridepublic void run() {synchronized (lock1) {System.out.println(Thread.currentThread().getName() + " get lock1");try {Thread.sleep(10);synchronized (lock2) {System.out.println(Thread.currentThread().getName() + " get lock2");}} catch (InterruptedException e) {e.printStackTrace();}}}});Thread threadB = new Thread(new Runnable() {@Overridepublic void run() {synchronized (lock2) {System.out.println(Thread.currentThread().getName() + " get lock2");try {Thread.sleep(10);synchronized (lock1) {System.out.println(Thread.currentThread().getName() + " get lock1");}} catch (InterruptedException e) {e.printStackTrace();}}}});threadA.start();threadB.start();TimeUnit.SECONDS.sleep(3);System.out.println("main thread begin to interrupt " + threadA.getName() + " and " + threadA.getName() + " will release lock1...");threadA.interrupt();}
}
运行结果:
【结论】如上图,main
线程中断Thread-0
后,Thread-0
并不会释放锁并醒过来。同样的,ReentrantLock
的tryLock
或lockInterruptibly
是可以被中断的。
5.2 synchronized锁可重入
5.2.1 不同方法,synchronized是可重入的
public class SynchronizeAndReentrant {public static void main(String[] args) throws Exception {SynchronizeAndReentrant synchronizeAndReentrant = new SynchronizeAndReentrant();synchronizeAndReentrant.test1();}public synchronized void test1(){System.out.println(" test1 method is called...");test2();}public synchronized void test2(){System.out.println(" test2 method is called...");}
}
运行结果:
5.2.2 相同方法,synchronized是可重入的
public class SynchronizeAndReentrant2 {int i = 1;public static void main(String[] args) throws Exception {SynchronizeAndReentrant2 synchronizeAndReentrant = new SynchronizeAndReentrant2();synchronizeAndReentrant.test1();}public synchronized void test1(){System.out.println(" test1 method is called " + i++ + "st time..." );while(i < 5) {test1();}}
}
运行结果:
5.3 synchronized锁不带超时功能
synchronized
锁不带超时功能,而ReentrantLock
的tryLock
是具备带超时功能的,在指定时间没获取到锁,该线程会苏醒,有助于预防死锁的产生。
5.4 唤醒/等待需要synchronized锁
public class NotifyNeedSynchronized {public static Object lock = new Object();public static void main(String[] args) throws Exception{// 抛出IllegalMonitorStateException//lock.notify();lock.wait();}
}
运行结果:
【结论】使用Object
的notify
和wait
等方法时,必须要使用synchronized
锁,否则会抛出IllegalMonitorStateException
。
5.5 使用synchronized锁时尽量缩小范围以保证性能
使用synchronized
锁时,为了尽可能提高性能,我们应该尽量缩小锁的范围。能不锁方法就不锁方法,推荐尽量使用synchronized
代码块来降低锁的范围。以下面的一段netty
源码为例:
// ServerBootstrap.javapublic <T> ServerBootstrap childOption(ChannelOption<T> childOption, T value) {if (childOption == null) {throw new NullPointerException("childOption");}if (value == null) {synchronized (childOptions) {childOptions.remove(childOption);}} else {synchronized (childOptions) {childOptions.put(childOption, value);}}return this;
}
可见,找到并发访问代码的临界区,并不用synchronized
锁全部代码,尽量避免使用synchronized
来修饰方法。
6 总结
本文对synchronized
的各种用法及注意事项通过demo
简单梳理了下,后面有时间会探讨下synchronized
的原理。
详解synchronized锁的各种用法及注意事项相关推荐
- 分析对象内部结构,并详解synchronized锁膨胀升级和降级的过程
1. 对象内部结构 一个对象内部结构由对象头.实例成员以及对齐填充组成.其中对象头由64位的Mark Word以及元数据指针和数组长度(只有数组对象才有)组成,其中元数据指针指向的是元空间中该对象的类 ...
- Java多线程系列(六):深入详解Synchronized同步锁的底层实现
谈到多线程就不得不谈到Synchronized,很多同学只会使用,缺不是很明白整个Synchronized的底层实现原理,这也是面试经常被问到的环节,比如: synchronized的底层实现原理 s ...
- 多线程---详解各种锁和AQS原理
详解各种锁与锁的使用 1. synchronized 可重入 同一个线程 不同线程 2. volatile 保证线程可见性 禁止指令重排序 查看结果 3. 锁优化 锁细化 锁粗化 锁对象 4. CAS ...
- AQS基础——多图详解CLH锁的原理与实现
1 什么是自旋锁和互斥锁? 由于CLH锁是一种自旋锁,那么我们先来看看自旋锁是什么? 自旋锁说白了也是一种互斥锁,只不过没有抢到锁的线程会一直自旋等待锁的释放,处于busy-waiting的状态,此时 ...
- 详解for循环(各种用法)
原文地址为: 详解for循环(各种用法) 常见的for循环一般是一下代码这种结构: for ( int i = 0 ; i < 100 ; i ++ ) { Consol ...
- html nthchild作用,详解CSS中:nth-child的用法
前端的哥们想必都接触过css中一个神奇的玩意,可以轻松选取你想要的标签并给与修改添加样式,是不是很给力,它就是":nth-child". 下面我将用几个典型的实例来给大家讲解:nt ...
- 详解SQL Server STUFF的用法
GPS平台.网站建设.软件开发.系统运维,找森大网络科技! https://cnsendnet.taobao.com 来自森大科技官方博客 http://www.cnsendblog.com/inde ...
- mysql 事务 for update,mysql事务锁_详解mysql 锁表 for update
摘要 腾兴网为您分享:详解mysql 锁表 for update,智慧农业,真还赚,悦读小说,学习帮等软件知识,以及电池管家,三国群英传3,userland,运满满货主版,王者荣耀,简单3d动画,嘉丽 ...
- php simplexml_load_file 详解,php中simplexml_load_file函数用法实例讲解
php中simplexml_load_file函数用法实例讲解 发布于 2015-02-07 06:53:40 | 136 次阅读 | 评论: 0 | 来源: 网友投递 PHP开源脚本语言PHP(外文 ...
最新文章
- mysql skip network_MYSQL-skip-networking
- @@identity、scope_identity()、IDENT_CURRENT('tablename')函数的区别
- 怎样做到真实再现传统文化艺术?
- mysql的远程链接工具_Navicat远程链接mysql-8数据库具体操作
- 对 makefile中 order-only 前提条件的理解
- Cocos2d-x 3.2 异步动态加载 -- 保卫萝卜开发总结
- Codeforces Round #686 (Div. 3) F. Array Partition 二分 + 线段树
- delphi7 如何判定dbgrid两行重复_教你如何在服装上加入好看的毛线刺绣花边
- php 一个URL加密解密的程序
- java用io流存信息_Java io流的学习
- 洛谷OJ P3368 【模板】树状数组 2
- 候鸟算法matlab实现
- CF909B Segments
- 浙大何越扬计算机系2 2,浙江大学第十一届大学生数学建模竞赛获奖名单.doc
- 2. 量化分析技术指标
- POJ 1088滑雪(3种解法)
- html2:什么是超文本?
- swiper 重新初始化
- window系统 安装 nvm 详细步骤
- 电脑搬家——SecureCRSecureFXPortable和SecureCRTPortable乱码
热门文章
- 应用随机过程张波商豪_Markov链的应用一:MCMC算法
- 教你如何运用golang 实现数组的随机排序
- DTD – XML 构建模块概述
- 动态导入ECMAScript模块一文看懂
- C 语言中 void* 详解及应用介绍
- 求n!(n的阶乘)和1!+2!+....n! (阶乘求和) ----C语言实现
- PTA数据结构与算法题目集6-4 6-3 6-8
- 思维dp ---- Codeforces Round #722 (Div. 1) B. Kavi on Pairing Duty [思维dp + 数学]
- js如何实现扫描身份证识别_人脸识别是如何实现的
- 服务器显示接口类型,查看服务器各接口卡情况的命令是:lspci