Java高并发关于synchronized的8锁讲解
先了解一个概念：synchronized 锁的是这个方法所在的资源类，就是这个对象，也就是同一时间段不可能有两个线程同时进到这个资源类，同一时间段，只允许有一个线程访问资源类里面的其中一个synchronized 方法！
T1：标准访问，请问先打印邮件还是短信？
public class Lock8 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(() -> {
try {
phone.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "A").start();
new Thread(() -> {
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "B").start();
}
}
class Phone {
public synchronized void sendEmail() throws Exception {
System.out.println("----sendEmail");
}
public synchronized void sendSMS() throws Exception {
System.out.println("----sendSMS");
}
}
结果：虽然先执行的sendEmail，但其实是不一定的，看cpu的调度，被 synchronized 修饰的方式，锁的对象是方法的调用者，因为这两个方法锁的是同一个对象，所以先调用的先执行。
T2：邮件方法暂停4s，请问先打印邮件还是短信？
代码如下：
public class Lock8 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(() -> {
try {
phone.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "A").start();
new Thread(() -> {
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "B").start();
}
}
class Phone {
public synchronized void sendEmail() throws Exception {
Thread.sleep(4000);
System.out.println("----sendEmail");
}
public synchronized void sendSMS() throws Exception {
System.out.println("----sendSMS");
}
}
结果：虽然先执行的（等待4s）sendEmail，然后接着sendSMS，但其实是不一定的，看cpu的调度，被 synchronized 修饰的方式，锁的对象是方法的调用者，因为这两个方法锁的是同一个对象，所以先调用的先执行，即先等待4s后sendEmail出现，接着sendSMS。相当于王小胖要拿手机发邮件，王二胖要拿手机发短息，王小胖先抢到手机了，它发邮件要4s的时间，那么就要等王小胖花4s发完邮件，王二胖才能发短信。
综合T1，T2，结论如下：
一个对象里面如果有多个synchronized 方法，某一时刻内，只要有一个线程去调用synchronized 方法了，那么其他的线程只能够等待，换句话说，某一时刻只能够有一个线程去访问这些synchronized方法，锁的是当前对象this，被锁定后，其他对象都不能进入到当前对象的其他synchronized 方法。
T3：新增一个普通方法hello()，请问先打印邮件还是hello？
代码如下：
public class Lock8 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(() -> {
try {
phone.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "A").start();
new Thread(() -> {
try {
// phone.sendSMS();
phone.hello();
} catch (Exception e) {
e.printStackTrace();
}
}, "B").start();
}
}
class Phone {
public synchronized void sendEmail() throws Exception {
Thread.sleep(4000);
System.out.println("----sendEmail");
}
public synchronized void sendSMS() throws Exception {
System.out.println("----sendSMS");
}
public void hello() {
System.out.println("----hello");
}
}
结果：结果是先打印hello，其次4s后再sendEmail，因为hello没有被synchronized 修饰。
结论：普通方法和同步锁无关。
T4：两部手机（两个资源实体），请问先打印邮件还是短信？
代码如下：
public class Lock8 {
public static void main(String[] args) {
Phone phone = new Phone();
Phone phone1 = new Phone();
new Thread(() -> {
try {
phone.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "A").start();
new Thread(() -> {
try {
// phone.sendSMS();
// phone.hello();
phone1.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "B").start();
}
}
class Phone {
public synchronized void sendEmail() throws Exception {
Thread.sleep(4000);
System.out.println("----sendEmail");
}
public synchronized void sendSMS() throws Exception {
System.out.println("----sendSMS");
}
public void hello() {
System.out.println("----hello");
}
}
结果：先打印的phone1的sendSMS，4s后再打印phone的sendemail，因为资源对象是不同的。
结论：两个对象，就不是同一把锁了。
T5：两个静态同步方法,同一部手机，请问先打印邮件还是短信？
public class Lock8 {
public static void main(String[] args) {
Phone phone = new Phone();
Phone phone1 = new Phone();
new Thread(() -> {
try {
phone.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "A").start();
new Thread(() -> {
try {
phone.sendSMS();
// phone.hello();
// phone1.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "B").start();
}
}
class Phone {
public static synchronized void sendEmail() throws Exception {
Thread.sleep(4000);
System.out.println("----sendEmail");
}
public static synchronized void sendSMS() throws Exception {
System.out.println("----sendSMS");
}
public void hello() {
System.out.println("----hello");
}
}
结果：4s过后先打印sendEmail，接着打印sendSMS。
T6:由上一题的一部手机换成两部手机，请问先打印邮件还是短信？
代码如下：
public class Lock8 {
public static void main(String[] args) {
Phone phone = new Phone();
Phone phone1 = new Phone();
new Thread(() -> {
try {
phone.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "A").start();
new Thread(() -> {
try {
// phone.sendSMS();
// phone.hello();
phone1.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "B").start();
}
}
class Phone {
public static synchronized void sendEmail() throws Exception {
Thread.sleep(4000);
System.out.println("----sendEmail");
}
public static synchronized void sendSMS() throws Exception {
System.out.println("----sendSMS");
}
public void hello() {
System.out.println("----hello");
}
}
结果：4s过后先打印sendEmail，接着打印sendSMS。
综合T5,T6：
结论：此时锁的不是对象了，而是类！即锁的是phone.class！锁的是模板，Phone phone=new Phone() 锁的就是这个Phone。
因为phone和phone1都是Phone的实例对象，而锁的是Phone，所以说，当phone正在执行的时候，phone1就得等着，因为锁的是模板。
T7：1个普通同步方法，1个静态同步方法，1部手机，请问先打印邮件还是短信？
代码如下：
public class Lock8 {
public static void main(String[] args) {
Phone phone = new Phone();
// Phone phone1 = new Phone();
new Thread(() -> {
try {
phone.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "A").start();
new Thread(() -> {
try {
phone.sendSMS();
// phone.hello();
// phone1.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "B").start();
}
}
class Phone {
public static synchronized void sendEmail() throws Exception {
Thread.sleep(4000);
System.out.println("----sendEmail");
}
public synchronized void sendSMS() throws Exception {
System.out.println("----sendSMS");
}
public void hello() {
System.out.println("----hello");
}
}
结果：先打印的sendSMS，接着4s后打印的sendEmail。原因：因为sendEmail锁的是模板的（加了static），sendSMS锁的是类的。
锁模板与锁类两者是不冲突的。由于sendEmail睡了4s所以先打印sendSMS.
T8：1个普通同步方法，1个静态同步方法，2部手机，请问先打印邮件还是短信？
代码如下：
public class Lock8 {
public static void main(String[] args) {
Phone phone = new Phone();
Phone phone1 = new Phone();
new Thread(() -> {
try {
phone.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "A").start();
new Thread(() -> {
try {
phone1.sendSMS();
// phone.hello();
// phone1.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "B").start();
}
}
class Phone {
public static synchronized void sendEmail() throws Exception {
Thread.sleep(4000);
System.out.println("----sendEmail");
}
public synchronized void sendSMS() throws Exception {
System.out.println("----sendSMS");
}
public void hello() {
System.out.println("----hello");
}
}
结果：同T7一样，先打印的sendSMS，接着4s后打印的sendEmail。原因：因为sendEmail锁的是模板的（加了static），sendSMS锁的是模板的实例对象的，而且操作的是不同的对象，两者是不冲突的。
8种加锁情景总结：
synchronized实现同步基础：java中的每一个对象都可以作为锁。当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。
synchronized的具体的表现形式有下面的三种：
1：对于普通方法而言public static synchronized void method(){...}，锁是当前实例对象。
也就是说当一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁。
如果别的实例对象的非静态同步方法和和该实例对象的非静态同步方法用的是不同的锁，那么就不用等待该实例对象已获取的锁的非静态同步方法释放锁，直接获取他们自己的锁。
2：对于静态同步方法public static synchronized void method(){...}，锁是当前类的class对象。
对象锁和类锁（this/class）是两个不同的对象，所以静态同步方法和非静态同步方法之间是不会有竞争条件的。但一旦静态方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁。
3：对于同步方法块而言用 synchronized（object）{代码内容}，锁是synchronized括号里配置的对象。
Java高并发关于synchronized的8锁讲解的更多相关文章
- java高并发核心要点|系列2|锁的底层实现原理
上篇文章,我们主要讲了解决多线程之间共享数据的核心问题和解决方案,也讲了锁的简单分类. 那么,这把锁,我们应该怎么去实现呢?如果你是java语言设计者,你又会怎么去设计这个线程锁呢? 直觉告诉我们,我 ...
- java高并发核心要点|系列3|锁的底层实现原理|ABA问题
继续讲CAS算法,上篇文章我们知道,CAS算法底层实现,是通过CPU的原子指令来实现. 那么这里又有一个情景: 话说,有一个线程one从内存位置V中取出A,这时候另一个线程two也从内存中取出A,并且 ...
- 【实战Java高并发程序设计 2】无锁的对象引用：AtomicReference
AtomicReference和AtomicInteger非常类似,不同之处就在于AtomicInteger是对整数的封装,而AtomicReference则对应普通的对象引用.也就是它可以保证你在修 ...
- 【实战Java高并发程序设计6】挑战无锁算法：无锁的Vector实现
[实战Java高并发程序设计 1]Java中的指针:Unsafe类 [实战Java高并发程序设计 2]无锁的对象引用:AtomicReference [实战Java高并发程序设计 3]带有时间戳的对象 ...
- 【实战Java高并发程序设计 7】让线程之间互相帮助--SynchronousQueue的实现
[实战Java高并发程序设计 1]Java中的指针:Unsafe类 [实战Java高并发程序设计 2]无锁的对象引用:AtomicReference [实战Java高并发程序设计 3]带有时间戳的对象 ...
- 【实战Java高并发程序设计 5】让普通变量也享受原子操作
[实战Java高并发程序设计 1]Java中的指针:Unsafe类 [实战Java高并发程序设计 2]无锁的对象引用:AtomicReference [实战Java高并发程序设计 3]带有时间戳的对象 ...
- 【实战Java高并发程序设计 3】带有时间戳的对象引用：AtomicStampedReference
[实战Java高并发程序设计 1]Java中的指针:Unsafe类 [实战Java高并发程序设计 2]无锁的对象引用:AtomicReference AtomicReference无法解决上述问题的根 ...
- java高并发核心要点|系列文章
java高并发核心要点|系列1|开篇 java高并发核心要点|系列2|锁的底层实现原理 java高并发核心要点|系列3|锁的底层实现原理|ABA问题 java高并发核心要点|系列4|CPU内存指令重排 ...
- java高并发锁的3种实现
初级技巧 - 乐观锁 乐观锁适合这样的场景:读不会冲突,写会冲突.同时读的频率远大于写. 以下面的代码为例,悲观锁的实现: Java代码 public Object get(Object key) ...
- 构建高性能服务（二）java高并发锁的3种实现
构建高性能服务(二)java高并发锁的3种实现 来源:http://www.xymyeah.com/?p=46 提高系统并发吞吐能力是构建高性能服务的重点和难点.通常review代码时看到sync ...
随机推荐
- [CEOI2011] Matching 题解
前言 题目链接:洛谷. 在上一题之后,模拟赛又放了一道 KMP 重定义相等的问题,但是寄了,故再记之. 题意简述 现在给出 \(1 \sim n\) 的排列 \(p\) 和序列 \(h_1, h_2, ...
- 用户案例 | Apache DolphinScheduler 离线调度在自如多业务场景下的应用与实践
用户案例 | 自如 随着自如业务的快速发展,不断增长的调度任务和历史逾万的存量任务对平台稳定性提出了更高的要求.同时,众多非专业开发人员也需要一种更为"亲民"的调度平台使用体验. ...
- mysql8.0.16免安装教程
Win10下免安装版MySQL8.0.16的安装和配置 1.MySQL8.0.16解压 其中dada文件夹和my.ini配置文件是解压后手动加入的,如下图所示 2.新建配置文件my.ini放在D: ...
- 零基础学习人工智能—Python—Pytorch学习（九）
前言 本文主要介绍卷积神经网络的使用的下半部分. 另外,上篇文章增加了一点代码注释,主要是解释(w-f+2p)/s+1这个公式的使用. 所以,要是这篇文章的代码看不太懂,可以翻一下上篇文章. 代码实现 ...
- Diskpart 操作
DiskPart 是 Windows 操作系统中的一个命令行工具,用于管理磁盘分区.它可以创建.删除.格式化和调整分区大小,还可以设置活动分区等.以下是一些常用的 DiskPart 命令和操作步骤. ...
- MATLAB 绘制 K 线图
需要安装 Financial Toolbox. % 示例数据 openPrices = [100, 102, 104, 103, 105]; highPrices = [105, 107, 106, ...
- Unable to tunnel through proxy. Proxy returns "HTTP/1.1 503 Service Unavailable"
背景: 某日,一正常项目迁移到新的服务器 新的服务器,需要使用代理来访问之前能直接访问的接口,加完代理之后,发现无法获取数据了 报错: org.springframework.web.client.R ...
- Pipeline流水线通过git拉取Jenkinsfile报错 error: RPC failed; result=22, HTTP code = 404
Pipeline流水线通过git拉取Jenkinsfile报错 error: RPC failed; result=22, HTTP code = 404 在学习共享库时使用通过git拉取jenkin ...
- Mongodb入门1
学如逆水行舟不进则退 | 心似平原走马易放难追 MongoDB是一个NOSQL类型的数据库,关于SQL与NOSQL的区别不是本文的重点,不在此进行记录. MongoDB安装 然后再将MongoDB的安 ...
- JavaScript Library – PhotoSwipe
效果 前言 以前用过 lightbox2 和 fancyapps. lightbox2 已经没有维护了. fancyapps 改版好多次了. v2, v3 现在 v4 已经开始收费了. PhotoSw ...