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括号里配置的对象
   

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

推荐阅读

• 

  莲子带芯的好还是不带芯的好
• 

  安卓手机wifi破解软件,安卓手机怎么破解?一晚可以破解
• 

  广州市东升医院2023年春节期间门诊安排
• 

  内关的作用与好处
• 

  静脉曲张吃药可以吃好吗?
• 

  感慨万端是什么意思 感慨万端的解释
• 

  plc培训班出来能工作吗，武汉plc培训后好找工作吗
• 

  妮维雅男士保湿啫喱 妮维雅男士保湿系列
• 

  立冬和冬至是一天吗
• 

  防诈骗简笔画教程防诈骗简笔画步骤
• 

  京东各行业数据分析,京东物流成本数据分析
• 

  二十四节气芒种的内涵寓意 芒种的内涵寓意为什么煮梅
• 

  algorand（可扩展的拜占庭协议）
• 

  口罩买什么样的好
• 

  Go|Go 语言 JSON 标准库的使用
• 

  月经期可以吃当归吗
• 

  遇到庆东锅炉指示面板不亮怎么办？3个处理方法帮助你
• 

  20180916v4.0目标和周检视第六周???吴文平
• 

  外貌协会的女生特点 外貌协会
• 

  给妈妈的礼物可以怎么做用纸

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