详解Synchronized锁的各种用法及注意事项
本文转载自微信公众号「源码笔记」，作者 源码笔记 。转载本文请联系源码笔记公众号。
创新互联主要从事成都做网站、网站建设、网页设计、企业做网站、公司建网站等业务。立足成都服务德宏州,十年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18982081108
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() {
- @Override
- public 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() {
- @Override
- public 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.java
- public
ServerBootstrap childOption(ChannelOption 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锁的各种用法及注意事项
标题路径：http://www.shufengxianlan.com/qtweb/news15/965.html
网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联
- 原生美国IP服务器租用要有哪些需要注意的？
- i510300h值得入手吗(i510300h处理器什么时候出来的？)
- 数据库行的重要性及管理技巧(数据库的行)
- storm怎么记
- (vfp物理删除流程？)
- 软件开发工程师技术债务的完整指南
- Move语言安全性分析及合约审计要点之逻辑校验漏洞
- 路由器重置网站是多少钱
- win10如何查找到计算机里的文件？（windows10中的生物识别）
- 物联网设备安全性及其对远程工作的影响
- server的三种安装方法？(如何安装服务器系统)
- 云服务器不能输入密码怎么解决
- 找不到sd卡怎么办？（找不到windowssd卡）
- 如何配置和管理Linux服务25个关键字（linux服务）
- 什么是xunizhuji,xunizhuji的定义及相关介绍