JUC高并发编程 六、多线程锁 6.1）演示锁的八种情况
6.1.1）标准访问
代码如下：

class Phone { // 打印短信 public synchronized void sendSMS() throws Exception { System.out.println("------sendSMS"); } // 打印邮件 public synchronized void sendEmail() throws Exception { System.out.println("------sendEmail"); } } ? public class Lock_8 { public static void main(String[] args) throws Exception { Phone phone = new Phone(); // 创建线程AA new Thread(() -> { try { phone.sendSMS(); } catch (Exception e) { e.printStackTrace(); } }, "AA").start(); ? Thread.sleep(100); // 创建线程BB new Thread(() -> { try { phone.sendEmail(); } catch (Exception e) { e.printStackTrace(); } }, "BB").start(); } }

输出：标准访问，先打印短后打印邮件

------sendSMS
------sendEmail

6.1.2）停4秒在短信方法内
代码如下：

class Phone { // 打印短信 public synchronized void sendSMS() throws Exception { //停留4秒 TimeUnit.SECONDS.sleep(4); System.out.println("------sendSMS"); } // 打印邮件 public synchronized void sendEmail() throws Exception { System.out.println("------sendEmail"); } } ? public class Lock_8 { public static void main(String[] args) throws Exception { Phone phone = new Phone(); // 创建线程AA new Thread(() -> { try { phone.sendSMS(); } catch (Exception e) { e.printStackTrace(); } }, "AA").start(); ? Thread.sleep(100); // 创建线程BB new Thread(() -> { try { phone.sendEmail(); } catch (Exception e) { e.printStackTrace(); } }, "BB").start(); } }

输出：停4秒在短信方法内，先打印短后打印邮件

------sendSMS
------sendEmail

说明：上述两种情况输出结果相同，表示添加 synchronized 关键字后加锁的是当前使用的对象(即phone)，即先执行phone.sendSMS()再执行phone.sendEmail()。
6.1.3）新增普通方法
代码如下：

class Phone { // 打印短信 public synchronized void sendSMS() throws Exception { //停留4秒 TimeUnit.SECONDS.sleep(4); System.out.println("------sendSMS"); } // 打印邮件 public synchronized void sendEmail() throws Exception { System.out.println("------sendEmail"); } // 普通方法 public void getHello() { System.out.println("------getHello"); } } ? public class Lock_8 { public static void main(String[] args) throws Exception { Phone phone = new Phone(); // 创建线程AA new Thread(() -> { try { phone.sendSMS(); } catch (Exception e) { e.printStackTrace(); } }, "AA").start(); ? Thread.sleep(100); // 创建线程BB new Thread(() -> { try { phone.getHello(); } catch (Exception e) { e.printStackTrace(); } }, "BB").start(); } }

输出：新增普通的hello方法，先执行普通hello方法再打印短信

------getHello
------sendSMS

说明：上述输出结果表示，不添加 synchronized关键字的普通方法先执行，添加synchronized关键字的方法后执行，即先执行phone.getHello()再执行phone.sendSMS()。
6.1.4）两部手机
代码如下：

class Phone { // 打印短信 public synchronized void sendSMS() throws Exception { //停留4秒 TimeUnit.SECONDS.sleep(4); System.out.println("------sendSMS"); } // 打印邮件 public synchronized void sendEmail() throws Exception { System.out.println("------sendEmail"); } } ? public class Lock_8 { public static void main(String[] args) throws Exception { Phone phone = new Phone(); Phone phone2 = new Phone(); // 创建线程AA new Thread(() -> { try { phone.sendSMS(); } catch (Exception e) { e.printStackTrace(); } }, "AA").start(); ? Thread.sleep(100); // 创建线程BB new Thread(() -> { try { phone2.sendEmail(); } catch (Exception e) { e.printStackTrace(); } }, "BB").start(); } }

输出：现在有两部手机，先打印邮件再打印短信

------sendEmail
-----sendSMS

说明：上述输出结果表示添加 synchronized 关键字后加锁的是当前使用的对象(即phone)，现在出现了2个对象所以加锁失效，因为实际上是加了2把锁，并不是同一把锁，即先执行phone2.sendEmail()再执行phone.sendSMS()。
6.1.5）两个静态同步方法，1部手机
代码如下：

class Phone { // 打印短信 public static synchronized void sendSMS() throws Exception { //停留4秒 TimeUnit.SECONDS.sleep(4); System.out.println("------sendSMS"); } // 打印邮件 public static synchronized void sendEmail() throws Exception { System.out.println("------sendEmail"); } } ? public class Lock_8 { public static void main(String[] args) throws Exception { Phone phone = new Phone(); // 创建线程AA new Thread(() -> { try { phone.sendSMS(); } catch (Exception e) { e.printStackTrace(); } }, "AA").start(); ? Thread.sleep(100); // 创建线程BB new Thread(() -> { try { phone.sendEmail(); } catch (Exception e) { e.printStackTrace(); } }, "BB").start(); } }

输出：两个静态同步方法，1部手机，先打印短信再打印邮件

------sendSMS
------sendEmail

6.1.6）两个静态同步方法，2部手机
代码如下：

class Phone { // 打印短信 public static synchronized void sendSMS() throws Exception { //停留4秒 TimeUnit.SECONDS.sleep(4); System.out.println("------sendSMS"); } // 打印邮件 public static synchronized void sendEmail() throws Exception { System.out.println("------sendEmail"); } } ? public class Lock_8 { public static void main(String[] args) throws Exception { Phone phone = new Phone(); Phone phone2 = new Phone(); // 创建线程AA new Thread(() -> { try { phone.sendSMS(); } catch (Exception e) { e.printStackTrace(); } }, "AA").start(); ? Thread.sleep(100); // 创建线程BB new Thread(() -> { try { phone2.sendEmail(); } catch (Exception e) { e.printStackTrace(); } }, "BB").start(); } }

输出：两个静态同步方法，2部手机，先打印短信再打印邮件

------sendSMS
------sendEmail

说明：上述两种情况输出结果相同，表示添加 static synchronized 关键字后加锁的是当前的字节码对象(即 class Phone )而不是实例对象(即 Phone )，相当于全局加锁了，即先执行phone2.sendEmail()再执行phone.sendSMS()。
6.1.7）1个静态同步方法,1个普通同步方法，1部手机
代码如下：

class Phone { // 打印短信 public static synchronized void sendSMS() throws Exception { //停留4秒 TimeUnit.SECONDS.sleep(4); System.out.println("------sendSMS"); } // 打印邮件 public synchronized void sendEmail() throws Exception { System.out.println("------sendEmail"); } } ? public class Lock_8 { public static void main(String[] args) throws Exception { Phone phone = new Phone(); // 创建线程AA new Thread(() -> { try { phone.sendSMS(); } catch (Exception e) { e.printStackTrace(); } }, "AA").start(); ? Thread.sleep(100); // 创建线程BB new Thread(() -> { try { phone.sendEmail(); } catch (Exception e) { e.printStackTrace(); } }, "BB").start(); } }

输出：1个静态同步方法,1个普通同步方法，1部手机，先打印邮件再打印短信

------sendEmail
------sendSMS

6.1.8）1个静态同步方法,1个普通同步方法，2部手机
代码如下：

class Phone { // 打印短信 public static synchronized void sendSMS() throws Exception { //停留4秒 TimeUnit.SECONDS.sleep(4); System.out.println("------sendSMS"); } // 打印邮件 public synchronized void sendEmail() throws Exception { System.out.println("------sendEmail"); } } ? public class Lock_8 { public static void main(String[] args) throws Exception { Phone phone = new Phone(); Phone phone2 = new Phone(); // 创建线程AA new Thread(() -> { try { phone.sendSMS(); } catch (Exception e) { e.printStackTrace(); } }, "AA").start(); ? Thread.sleep(100); // 创建线程BB new Thread(() -> { try { phone2.sendEmail(); } catch (Exception e) { e.printStackTrace(); } }, "BB").start(); } }

输出：1个静态同步方法,1个普通同步方法，2部手机，先打印邮件再打印短信

------sendEmail
------sendSMS

说明：上述两种情况输出结果相同，表示静态同步方法和普通同步方法的加锁对象不同，还是2把锁，所以锁实际是失效的，即先执行phone2.sendEmail()再执行phone.sendSMS()。
6.1.9）小结
一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了， 其它的线程都只能等待，就是说，某一个时刻内只能有唯一一个线程去访问这些 synchronized方法；
【高并发|JUC高并发编程(07) -- 多线程锁 -- 演示锁的八种情况】锁的是当前this对象，被锁定后，其它的线程都不能进入到当前对象的其它的 synchronized方法，加入普通方法后发现和同步锁无关；
换成两个对象后，不是同一把锁了，锁实际上是无效的。
synchronized实现同步的基础：Java中的每一个对象都可以作为锁，具体表现为以下3种形式：

1. 对于普通同步方法，锁是当前实例对象；
   
2. 对于静态同步方法，锁是当前类的Class对象；
   
3. 对于同步方法块，锁是Synchonized括号里配置的对象
   

当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁；也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步 法必须等待获取锁的方法释放锁后才能获取锁， 可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁， 所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。
所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象， 以静态同步方法与非静态同步方法之间是不会有竞态条件的。
但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间还是不同的实例对象的静态同 步方法之间，只要它们同一个类的实例对象！

推荐阅读

• 

  飞亚达手表回收 飞亚达机械手表价格
• 

  知心爱人付笛声任静歌词知心爱人歌曲任静,付笛声简谱
• 

  识别情绪，控制和养成情绪
• 

  脊髓再生成功 高位截瘫吧
• 

  广州积分入学小学积分后初中还要积分吗
• 

  耳朵疼是怎么回事
• 

  mysql模糊查询匹配最优 mysql多条件模糊查找
• 

  凝聚的近义词是什么词？凝聚的近义词是什么?
• 

  秦国是如何从弱小走向霸主的呢？
• 

  车辆保养多久做一次?汽车保养明细表大全 车辆保养多久做一次
• 

  浅谈《伤寒论》的辨证思维方式
• 

  描能组什么词语
• 

  医生|50岁的阿姨抽出“猪油血”，医生提醒：春节饮食要注意
• 

  爱普生打印机固件刷机
• 

  对于非法出售增值税专用发票案公安追诉标准是多少
• 

  绘本讲师训练营【31期】20/21实践原创《鳄鱼怕怕，牙医怕怕》
• 

  快速调出照片的梦幻紫色调
• 

  吃啥降低胆固醇最快 吃什么降低胆固醇最快
• 

  系统安全性分析
• 

  酸梅汤的功效与作用 夏季喝酸梅汤有啥好处

• 常见的注解
• #|Oracle数据库操作
• 云计算|云计算技术与应用 -基础概念与分布式计算
• 面试官（Nginx 是如何实现并发的（为什么 Nginx 不使用多线程？））
• 面试·求职系列|Java8新特性 十二大总结 （面试篇）
• 面试·求职系列|【面试篇】手写单例模式及原理剖析
• linux|前后端分离 -- Spring Boot + Vue实现视频管理系统 并部署阿里云服务器
• 阿里云服务器相关|云原生Java架构师的第一课阿里云部署-KubeSphere平台安装
• 【面试普通人VS高手】Spring 中Bean的作用域有哪些（）