Synchronized的一些思考

最新推荐文章于 2022-05-08 10:14:44 发布
最新推荐文章于 2022-05-08 10:14:44 发布
阅读量273 收藏
点赞数
分类专栏： Java 文章标签： Java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z3jjlzt/article/details/79143406
版权

前些天被问到Synchronized关键字的一些用法和区别，发现自己的理解比较浅，因此在这作一个总结。

0x00 定义

synchronized是一种同步锁。采用synchronized修饰符实现的同步机制叫做互斥锁机制，它所获得的锁叫做互斥锁。每个对象都有一个monitor(锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程，因此叫做互斥锁。

0x01 使用场景

按照作用域的划分，可以分为以下四种。

  1. 修饰代码块，作用范围为{}之间的代码，作用的对象是调用这个代码块的对象。
  2. 修饰普通方法，作用范围为整个方法，作用的对象为调用该方法的对象实例。
  3. 修饰静态方法，作用范围为整个类，作用的对象为该类的所有对象实例。
  4. 修饰类，如synchronized(xxx.class）{}，作用的范围为{}部分，作用的对象为该类的所有对象实例。

0x11 修饰代码块

package com.kkk.pattern;

/**
 * Created by z3jjlzt on 2018/1/23.
 */
public class SyncTest {
    private void pNum(int num) {
        synchronized(this){
            System.out.println(Thread.currentThread());
            for (int i = 0; i < 10; i++) {
                System.out.print("^"+ i + "*");
            }
            System.out.println();
        }
    }
    static class r implements Runnable {
        SyncTest syncTest;
        int num;

        public r(SyncTest syncTest, int num) {
            this.syncTest = syncTest;
            this.num = num;
        }

        @Override
        public void run() {
            while (true) {
                this.syncTest.pNum(this.num);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        SyncTest syncTest = new SyncTest();
        Thread thread = new Thread(new r(syncTest, 1));
        Thread thread1 = new Thread(new r(syncTest, 1));
        thread.start();
        thread1.start();
    }
}
输出结果：
Thread[Thread-0,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-1,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-0,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-1,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-0,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-1,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
...

通过输出可以看出，当多个线程同时调用一个synchronized方法时，在同一时间，只能有一个线程能够持有该方法的锁并执行该方法，其他线程只能等待。
需要注意的时，在两个线程中，传入的时同一个对象SyncTest，如果传入的对象不相同，那么两个线程的代码可以并发执行，原因是synchronized只锁定对象实例，不同对象实例之间的锁互不影响。

0x11 修饰普通方法

package com.kkk.pattern;

/**
 * Created by z3jjlzt on 2018/1/23.
 */
public class SyncTest {
    private synchronized void pNum(int num) {
        System.out.println(Thread.currentThread());
        for (int i = 0; i < 10; i++) {
            System.out.print("^"+ i + "*");
        }
        System.out.println();
    }
    static class r implements Runnable {
        SyncTest syncTest;
        int num;

        public r(SyncTest syncTest, int num) {
            this.syncTest = syncTest;
            this.num = num;
        }

        @Override
        public void run() {
            while (true) {
                this.syncTest.pNum(this.num);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        SyncTest syncTest = new SyncTest();
        Thread thread = new Thread(new r(syncTest, 1));
        Thread thread1 = new Thread(new r(syncTest, 1));
        thread.start();
        thread1.start();
    }
}
输出结果：
Thread[Thread-0,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-1,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-0,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-1,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-0,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-1,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
...

输出结果和前面相同，但由于synchronized的系统开销比较大，所以在都能实现功能的前提下，尽量多使用同步代码块的方式来减少系统开销。

0x100 修饰静态方法

package com.kkk.pattern;

/**
 * Created by z3jjlzt on 2018/1/23.
 */
public class SyncTest {
    private static synchronized void pNum(int num) {
        System.out.println(Thread.currentThread());
        for (int i = 0; i < 10; i++) {
            System.out.print("^"+ i + "*");
        }
        System.out.println();
    }
    static class r implements Runnable {
        SyncTest syncTest;
        int num;

        public r(SyncTest syncTest, int num) {
            this.syncTest = syncTest;
            this.num = num;
        }

        @Override
        public void run() {
            while (true) {
                this.syncTest.pNum(this.num);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        SyncTest syncTest = new SyncTest();
        SyncTest syncTest1 = new SyncTest();
        Thread thread = new Thread(new r(syncTest, 1));
        Thread thread1 = new Thread(new r(syncTest1, 1));
        thread.start();
        thread1.start();
    }
}
输出结果：
Thread[Thread-0,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-1,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-0,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-1,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-0,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-1,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
...

在该情况下，synchronized作用的对象是类的所有实例对象。

0x101 修饰一个类

package com.kkk.pattern;

/**
 * Created by z3jjlzt on 2018/1/23.
 */
public class SyncTest {
    private void pNum(int num) {
        synchronized(this){
            System.out.println(Thread.currentThread());
            for (int i = 0; i < 10; i++) {
                System.out.print("^"+ i + "*");
            }
            System.out.println();
        }
    }
    static class r implements Runnable {
        SyncTest syncTest;
        int num;

        public r(SyncTest syncTest, int num) {
            this.syncTest = syncTest;
            this.num = num;
        }

        @Override
        public void run() {
            while (true) {
                this.syncTest.pNum(this.num);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        SyncTest syncTest = new SyncTest();
        SyncTest syncTest1 = new SyncTest();
        Thread thread = new Thread(new r(syncTest, 1));
        Thread thread1 = new Thread(new r(syncTest1, 1));
        thread.start();
        thread1.start();
    }
}
输出结果：
Thread[Thread-0,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-1,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-0,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-1,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-0,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
Thread[Thread-1,5,main]
^0*^1*^2*^3*^4*^5*^6*^7*^8*^9*
...

输出结果和修饰静态方法是一致的。

0x110 一些补充

  • 在同一个对象实例中，有多个synchronized修饰的普通方法，多个线程同时访问这些方法（同一个对象实例中），在同一时间内，只能有一个线程能够取得该对象的锁并执行程序，因为在同步方法中，只有获取了锁才能执行方法，而一个对象只有一个锁。
  • 当只是想让一段代码同步时，可以创建一个特殊的对象来充当锁,生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

0xff 参考

我的学长是王欣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
理解synchronized
qq_23986927的博客
08-17 626
JAVA架构师之路 本系列文章均是博主原创，意在记录学习上的知识，同时一起分享学习心得。 第一章 第一节 Java集合总结（架构师之路 ） 第二节 Java多线程（架构师之路 ） 第三节 理解synchronized（架构师之路 ） 文章目录JAVA架构师之路前言一、synchronize是什么？二、用法和基本原理1.实例方法2.静态方法3.代码块三、进一步理解synchronized3.1 可重入性3.2 内存可见性3.3 死锁 前言 本章节介绍synchronize的知识，可以解决竞态条件和内存可
浅说Synchronized
Cr1556648487的博客
08-23 140
synchronized关键字用来保证在同一时刻只有一个线程可以执行被它修饰的变量或者代码块。这一篇中，只涉及synchronized的底层实现原理，不涉及对synchronized效率以及如何优化的讨论。
两种创建线程的方式
LLcwh的博客
05-28 378
继承java.lang.Thread类 public class FirstThread extends Thread{ private int i ; @Override public void run() { // 真正去运行线程，执行任务 for (i = 0; i < 50; i++) { System.out.println(getName() + " 运行 : " + i); } } public static void main(String[]
并发（1）中断线程，线程的状态，线程属性。
qq_35583089的博客
05-24 393
一 ，中断线程      获取当前线程： System.out.println(Thread.currentThread());       结果为：Thread[main,5,main]   指的是当前线程的字符串表示形式。Thread[main,5,main]为主线程的表示方式，中括号里的第一个值为当前主线程的名字，第二个为线程级别，第三个为线程组。Thread[Thread-0,5,main...
Thread类的常用方法_获取线程名称
老王玩编程
09-27 506
主线程 MyThread01Thread package cn.itcast.day12.demo05; /** * @author admin * @version 1.0.0 * @ClassName MyThread01Thread.java * @Description TODO * @createTime 2021年09月27日 20:38:00 */ /** * 线程名称： * 主线程：main * 新线程：name = Thread-0，Thr.
多线程并发情况下的数据一致性问题
java小白翻身
05-08 2821
首先，有一个静态的布尔变量： publicstaticbooleanflag = false; 然后，开启两个线程。 A线程： newThread(()-> { System.out.println(Thread.currentThread()+ "start..."); while(!flag) { } System.out.println(Thread.currentThread()+ "success..."); }).sta......
review引发的有关于单例模式的思考
09-05
为了解决这个问题，作者将`createClient()`方法改为同步的（synchronized），确保同一时间只有一个线程能够执行创建实例的代码，从而保证了单例的正确性。 除了同步方法之外，还有其他几种常见的解决单例模式并发...
[探秘Java：如何像计算机科学家一样思考].(唐尼).张平.扫描版.pdf
08-04
Java提供了丰富的并发工具，如线程、同步机制（如synchronized关键字和Lock接口）、并发集合等。理解并能熟练运用这些工具，可以使Java程序员编写出高效且安全的多线程程序。 此外，书中可能会讨论IO和NIO（非阻塞I...
ThinkingInJava:在Java中思考
04-28
《ThinkingInJava:在Java中思考》是一本深入探讨Java编程思想的著作，它涵盖了Java语言的核心概念、设计模式以及高级特性。这本书以其详尽的解释和丰富的示例，为开发者提供了一个全面理解Java编程的平台。以下是...
Concurrency:“ Java思考”的并发代码
05-16
4. **同步机制**：为了避免多个线程访问共享数据时可能产生的竞态条件，Java提供了`synchronized`关键字和`Lock`接口。`synchronized`用于同步方法或同步块，确保同一时间只有一个线程能执行特定代码段。`Lock`提供...
java-se:java基础巩固，思考
04-13
Java是一种广泛使用的...通过不断巩固和思考这些知识点，你将能够在Java世界中游刃有余，无论是开发桌面应用、Web应用还是移动应用，都能得心应手。在实际项目中不断实践和学习，你将逐渐成长为一名精通Java的开发者。
java多线程（九）阻塞队列
xingjiarong的专栏
08-28 2522
前边的博客中我们介绍了如果用对象锁和条件锁以及更加方便的synchronized关键字来实现多线程的同步和互斥，也许你会觉得使用synchronized关键字已经非常方便了，但是使用者必须真正的理解synchronized的用法，而且要有一定的多线程的编程的经验，否则很难做到全面的考虑问题而造成意想不到的问题。其实在java中还有比
JAVA——多线程
Castanea的博客
05-22 199
先看一看多线程的执行public class MyThread extends Thread{ @Override public void run() { for (int i =0;i&lt;10;i++){ System.out.println(getName()+"-" +i); } } }public clas...
Java线程学习笔记（五）：线程的优先级
IT民工
07-09 190
线程的“优先级”将线程的重要性传递给了调度器。尽管CPU处理现有线程集的顺序是不确定的。但是调度器将倾向于让优先权最高的线程先执行。然而，这并不意味着优先权较低的线程将得不到执行（也就是说，优先权不会导致死锁）。优先级较低的线程，仅仅是执行的频率较低。 在绝大多数的时间里，所有线程都应该以默认的优先级运行。 JDK中有10个优先级，但它与大多数操作系统都不能映射的很好。比如，Windows...
Java日志八「线程」
S_8casrces的博客
07-28 171
** 线程 ** 在说线程之前，有必要提一下什么是进程。进程是具有一个独立功能的程序关于某个数据集合上的一次运行活动，是系统进行资源分配和调度的一个单独单位。 而线程是进程的一个实体，是CPU调度和分派的基本单位，他是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器，一组寄存器和栈），一个线程可以创建和撤销另一个线程。 进程和线程的关系： 1.一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。 2.资源分配给进程，同一进程的所
《Thinking in Java》读书笔记之并发（五）
Ghost Stories
04-09 502
让步 如果知道已经完成了在run()方法的循环的一次迭代过程中所需的工作，就可以给线程调度机制一个暗示：你的工作已近做的差不多了，可以让别的线程使用CPU了，这个暗示将通过调用yield()方法作出（不过这只是一个暗示，没有任何机制保证它将被采纳），当调用yield()时，你也是在建议具有相同优先级的其他线程可以运行
Thread类currenThread方法输出含义
weixin_45026853的博客
04-07 408
dame04.currentThread(); //输出的结果：Thread[Thread-0,5,main] 其含义：Thread[" + getName() + “,” + getPriority() + “,” + group.getName() + "] 改变其PriOrity：setPriority
超市管理系统，基于javaweb.zip
最新发布
08-15
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松copy复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全栈开发），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助 【资源内容】：项目具体内容可查看/点击本页面下方的*资源详情*，包含完整源码+工程文件+说明（若有）等。【若无积分，此资源可私信获取】 【本人专注IT领域】：有任何使用问题欢迎随时与我联系，我会及时解答，第一时间为您提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【适合场景】：相关项目设计中，皆可应用在项目开发、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面中 可借鉴此优质项目实现复刻，也可基于此项目来扩展开发出更多功能 #注 1. 本资源仅用于开源学习和技术交流。不可商用等，一切后果由使用者承担 2. 部分字体及插图等来自网络，若是侵权请联系删除，本人不对所涉及的版权问题或内容负法律责任。收取的费用仅用于收集和整理资料耗费时间的酬劳
深入学习Java：思考的艺术
5. 多线程处理：介绍线程的概念，线程同步机制（如synchronized关键字和wait/notify机制），以及线程池的使用。 6. 虚拟机性能：讨论Java虚拟机（JVM）的工作原理，内存管理，垃圾收集，以及如何优化Java程序的运行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值