JUC（二）——深入理解锁机制

最新推荐文章于 2024-01-16 13:44:52 发布
最新推荐文章于 2024-01-16 13:44:52 发布
阅读量293 收藏 1
点赞数 1
分类专栏： Java高级 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41939020/article/details/103609086
版权

JUC（一）——Locks
JUC（二）——深入理解锁机制
JUC（三）——线程安全类
JUC（四）——强大的辅助类讲解
JUC（五）——Callable
JUC（六）——阻塞队列
JUC（七）——线程池简单使用
JUC（八）——线程池深入讲解

对于锁大家肯定都不陌生，锁分为synchronize和lock

但是大家是否知道锁到底锁住的是什么呢？

接下来我们举几个例子来了解锁（这里使用synchronize来演示）

  • 1、该代码先打印的是短信还是邮件？
       class Phone
   {
   
       public synchronized void sendSMS() throws Exception
       {
           System.out.println("------短信");
       }
       public synchronized void sendEmail() throws Exception
       {
           System.out.println("------邮件");
       }
   
       public void getHello()
       {
           System.out.println("------hello");
       }
   
   }
   public class Lock
   {
       public static void main(String[] args) throws Exception
       {
   
           Phone phone = new Phone();
   
           new Thread(() -> {
               try {
                   phone.sendSMS();
               } catch (Exception e) {
                   e.printStackTrace();
               }
           }, "AA").start();
   
           Thread.sleep(100);
   
           new Thread(() -> {
               try {
                   phone.sendEmail();
               } catch (Exception e) {
                   e.printStackTrace();
               }
           }, "BB").start();
       }
   }
    • 结果：短信（我们结合第二个例子一起解释）
  • 2、停4秒在短信方法内，该代码先打印的是短信还是邮件？ 
    •   class Phone
  {
  
      public synchronized void sendSMS() throws Exception
      {
          TimeUnit.SECONDS.sleep(4);
          System.out.println("------短信");
      }
      public synchronized void sendEmail() throws Exception
      {
          System.out.println("------邮件");
      }
  
      public void getHello()
      {
          System.out.println("------hello");
      }
  
  }
  public class Lock
  {
      public static void main(String[] args) throws Exception
      {
  
          Phone phone = new Phone();
  
          new Thread(() -> {
              try {
                  phone.sendSMS();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "AA").start();
  
          Thread.sleep(100);
  
          new Thread(() -> {
              try {
                  phone.sendEmail();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "BB").start();
      }
  }
    • 结果：短信
    • 讲解：
      • 一个对象里面如果有多个被synchronize锁住的普通方法，如果某一个时刻内，只要有一个线程去调用其中的一个synchronized方法了，那么其它的线程都只能等待
      • 换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法
      • 此时锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法
  • 3、普通的hello方法，该代码先打印短信还是hello 
    •   class Phone
  {
  
      public synchronized void sendSMS() throws Exception
      {
          TimeUnit.SECONDS.sleep(4);
          System.out.println("------短信");
      }
      public synchronized void sendEmail() throws Exception
      {
          System.out.println("------邮件");
      }
  
      public void getHello()
      {
          System.out.println("------hello");
      }
  
  }
  public class Lock
  {
      public static void main(String[] args) throws Exception
      {
  
          Phone phone = new Phone();
  
          new Thread(() -> {
              try {
                  phone.sendSMS();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "AA").start();
  
          Thread.sleep(100);
  
          new Thread(() -> {
              try {
                  phone.getHello();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "BB").start();
      }
  }
    • 结果：hello
    • 结论： 普通方法和同步锁无关
  • 4、现在有两部手机，该代码先打印的是短信还是邮件？ 
    •   class Phone
  {
  
      public synchronized void sendSMS() throws Exception
      {
          TimeUnit.SECONDS.sleep(4);
          System.out.println("------短信");
      }
      public synchronized void sendEmail() throws Exception
      {
          System.out.println("------邮件");
      }
  
      public void getHello()
      {
          System.out.println("------hello");
      }
  
  }
  public class Lock
  {
      public static void main(String[] args) throws Exception
      {
  
          Phone phone = new Phone();
  		  Phone phone2 = new Phone();
          new Thread(() -> {
              try {
                  phone.sendSMS();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "AA").start();
  
          Thread.sleep(100);
  
          new Thread(() -> {
              try {
                  phone2.getHello();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "BB").start();
      }
  }
    • 结果：邮件
    • 结论： 锁的是对象，两个不同的对象是互不影响的
  • 5、两个静态同步方法，1部手机，该代码先打印的是短信还是邮件？ 
    •   class Phone
  {
  
      public static synchronized void sendSMS() throws Exception
      {
          TimeUnit.SECONDS.sleep(4);
          System.out.println("------短信");
      }
      public static synchronized void sendEmail() throws Exception
      {
          System.out.println("------邮件");
      }
  
      public void getHello()
      {
          System.out.println("------hello");
      }
  
  }
  public class Lock
  {
      public static void main(String[] args) throws Exception
      {
  
          Phone phone = new Phone();
  
          new Thread(() -> {
              try {
                  phone.sendSMS();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "AA").start();
  
          Thread.sleep(100);
  
          new Thread(() -> {
              try {
                  phone.sendEmail();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "BB").start();
      }
  }
    • 结果：短信（和下一个例子一起说）
  • 6、两个静态同步方法，2部手机，该代码先打印的是短信还是邮件？ 
    •  class Phone
 {
 
     public static synchronized void sendSMS() throws Exception
     {
         TimeUnit.SECONDS.sleep(4);
         System.out.println("------短信");
     }
     public static synchronized void sendEmail() throws Exception
     {
         System.out.println("------邮件");
     }
 
     public void getHello()
     {
         System.out.println("------hello");
     }
 
 }
 public class Lock
 {
     public static void main(String[] args) throws Exception
     {
 
         Phone phone = new Phone();
 		 Phone phone2 = new Phone();
         new Thread(() -> {
             try {
                 phone.sendSMS();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }, "AA").start();
 
         Thread.sleep(100);
 
         new Thread(() -> {
             try {
                 phone2.sendEmail();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }, "BB").start();
     }
 }
    • 结果：短信
    • 结论： 对静态方法加锁，锁住的不在是对象，而是这个类。即该类中所有的静态加锁方法用的是同一把锁
  • 7、1个静态同步方法,1个普通同步方法，1部手机，该代码先打印的是短信还是邮件？ 
    •   class Phone
  {
  
      public static synchronized void sendSMS() throws Exception
      {
          TimeUnit.SECONDS.sleep(4);
          System.out.println("------短信");
      }
      public synchronized void sendEmail() throws Exception
      {
          System.out.println("------邮件");
      }
  
      public void getHello()
      {
          System.out.println("------hello");
      }
  
  }
  public class Lock
  {
      public static void main(String[] args) throws Exception
      {
  
          Phone phone = new Phone();
          
          new Thread(() -> {
              try {
                  phone.sendSMS();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "AA").start();
  
          Thread.sleep(100);
  
          new Thread(() -> {
              try {
                  phone.sendEmail();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "BB").start();
      }
  }
    • 结果：邮件（结论和下个例子一起说）
  • 8、1个静态同步方法,1个普通同步方法，2部手机，先打印短信还是邮件 
    •   class Phone
  {
  
      public static synchronized void sendSMS() throws Exception
      {
          TimeUnit.SECONDS.sleep(4);
          System.out.println("------短信");
      }
      public synchronized void sendEmail() throws Exception
      {
          System.out.println("------邮件");
      }
  
      public void getHello()
      {
          System.out.println("------hello");
      }
  
  }
  public class Lock
  {
      public static void main(String[] args) throws Exception
      {
  
          Phone phone = new Phone();
          Phone phone2 = new Phone();
          new Thread(() -> {
              try {
                  phone.sendSMS();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "AA").start();
  
          Thread.sleep(100);
  
          new Thread(() -> {
              try {
                  phone2.sendEmail();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "BB").start();
      }
  }
    • 结果：邮件
    • 结论： 静态加锁锁的是类，普通加锁方法锁的是对象，两个锁互不干扰

总结

  • 对于普通同步方法，锁是当前实例对象。
  • 对于静态同步方法，锁是当前类的Class对象。
  • 不同的锁之间或不干扰，上锁的方法和没上锁的方法或不干扰
# Never Give up &
关注
专栏目录
【并发】并发锁机制-深入理解synchronized（二）
金鳞踏雨
01-12 571
Mark Word用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等，这部分数据的长度在32位和64位的虚拟机中分别为32bit和64bit，官方称它为“Mark Word”。对象头的另外一部分是klass类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。32位4字节，64位开启指针压缩或最大堆内存数组长度（只有数组对象有）如果对象是一个数组, 那在对象头中还必须有一块数据用于记录数组长度。
三、JUC提升——java的CAS原理解析含ABA问题解决
马疯蜗的博客
07-08 359
CAS--Compare And SwapCompare And Swap（比较交换）一、定义:三级目录 Compare And Swap（比较交换） 一、定义: 当多个线程尝试使用CAS同时更新同一个变量时,只有其中一个线程能更新变量的值，而其他线程都失败，失败的线程并不会被挂起，而是被告知竞争失败，并可再次尝试！它是基于硬件平台的汇编指令。 三级目录 ...
JUC线程框架深度解析 — 02、线程同步锁
androidsj的专栏
05-08 2387
     juc的开发架构解决的核心问题是并发访问与数据安全操作问题，当进行并发访问的时候如果对于锁的控制不当，就会造成死锁这样的阻塞问题，那么为了解决这样的缺陷，juc里面重新针对锁的概念进行了设计。【 JUC锁机制 】➣ JUC锁机制包括有如下组成部分：   ➣ 核心接口：Lock、ReadWriteLock；   ➣ AQS抽象类：• AbstractOwnableSynchronizer(...
JUC——线程同步锁（锁处理机制简介）
weixin_34210740的博客
04-26 163
锁处理机制简介 juc的开发框架解决的核心问题是并发访问和数据安全操作问题，当进行并发访问的时候如果对于锁的控制不当，就会造成死锁这样的阻塞问题。 为了解决这样的缺陷，juc里面重新针对于锁的概念进行了设计。 JUC锁机制 JUC锁机制包括以下几个组成部分： 核心接口：Lock，ReadWriteLock； AQS抽象类： AbstractOwnableSynchron...
锁机制（JUC）
最新发布
weixin_61494821的博客
01-16 917
锁机制（JUC）
JUC原理之锁机制原理一
lsd&xql的博客
03-28 365
计算机底层简单介绍 JUC出现的原因？ 为java语言提供多线程同步结构的支撑 JUC解决了什么问题？ 用于解决多线程同步问题，给Java开发者提供便利的函数和功能、结构 JUC包含了哪些内容？ 原子类、锁类、工具类（线程同步结构、线程池等等） 如何实现一把锁？ 1、表示当前锁状态 2、保证多线程抢锁线程安全 3、处理没有获取到锁的线程 4、释放锁后如何处理未获得锁的线程 ...
【java并发】juc高级锁机制探讨
肖的专栏
07-16 463
最近在看一些juc相关的设计和源码，接上文：【java并发】基于JUC CAS原理,自己实现简单独占锁 本文探讨一下juc里面提供的一些高级锁机制和基本原理。   JUC高级锁机制简介 Juc提供了高级锁的一些特性和应用，如： ReentrantLock：和synchronized具有差不多的语义，独占锁，同时只有一个线程能获得锁。 ReentrantReadWriteLock：读写锁
Java——深入理解多线程中的锁
weixin_41438466的博客
10-03 318
前言 在Java并发编程中锁的知识是必备的，所以如果在做并发项目的话，这篇文章或多或少都会给你一些想要的，本文主要从概念思想来深入理解Java中的锁，当然如果想要看代码实现的可以在下面这篇文章中查阅 《Java锁详解——lock的实现》 1. 整体了解Java多线程中的锁 看下面这张图片我们可以大体了解锁的种类 接下来对各种锁进行详细说明 2. 悲观锁和乐观锁 这两种主要是看开发人员对线程安全...
深入理解JUC——线程及常见方法
Inception查缺补漏
08-26 242
Java并发的基础是进程与线程，本文主要介绍了线程与进程的关系， 以及object类中与线程相关的方法。
深入理解JUC——CPU缓存及volatile
Inception查缺补漏
08-26 309
CPU 缓存是为了解决CPU 处理速度和内存处理速度不对等的问题。由于计算机的存储设备与处理器的运算速度有着几个数量级的差距，需要设计多级缓存，将运算需要使用的数据复制到缓存中，让运算能快速进行，当运算结束后再从缓存同步回内存之中，这样处理器就无须等待缓慢的内存读写...
多线程透析--JUC的锁机制、锁原理CAS、AQS
qq_31142237的博客
04-21 580
多线程透析–JUC的锁机制、锁原理 其实之前博客中就已经提到了JUC，今天详细的透析下JUC的锁机制和锁原理。 在JDK1.1~1.2 的时候 只有synchronize锁，此时的锁只是一个重量级锁，所谓的重量级锁我个人理解就是线程在使用资源时需要通过OS线程队列进行调度，只有在获取锁（没有其他线程占用锁）的情况下才能进行。这类锁一般具有排他性，所以也叫悲观锁。 而早期的synchronize不管你是否是多线程竞争关系，都会同样的采取重量级锁这一套。这样再简单的线程操作中，就很影响效率。 在JDK 1.5
Java之JUC系列（02）--锁机制
Runner的博客
02-22 547
Java并发工具包锁机制
JUC系列（三）Lock 锁机制详解 代码理论相结合
北
08-21 308
本章内容涵盖Lock的使用讲解，可重入锁、读写锁。Lock和Synchronized的对比等。 多线程一直Java开发中的难点，也是面试中的常客，趁着还有时间，打算巩固一下JUC方面知识，我想机会随处可见，但始终都是留给有准备的人的，希望我们都能加油！！！ 沉下去，再浮上来，我想我们会变的不一样的。 JUC系列（三）Lock 详解一、什么是 Lock二、锁类型三、Lock接口3.1、lock()、unlock（）3.2、newCondition四、ReentrantLock （可重入锁）五、ReadWr.
一文速通JUC中的各种锁
一个菜鸡的博客
03-31 589
一文带你打通乐观锁和悲观锁、公平锁和非公平锁、递归锁(可重入锁)、死锁及排查、自旋锁
JUC高级二: Java锁(上篇)
qq_31745863的博客
03-19 505
锁一锁二一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一的一个线程去访问这些synchronized方法锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法锁三锁四加个普通方法后发现和同步锁无关换成两个对象后，不是同一把锁了，情况立刻变化,即两把锁不会锁住对方锁五锁六对于。
java.sql.SQLException: Failed to fetch schema of pms_spu_info_desc
# Never Give up &
01-08 2100
无法获取pms_spu_info_desc的架构 错误原因： 项目中使用了seata来管理事务，但是在pms_spu_info_desc数据库表中没有设置主键 解决方法： 为对应的数据库表设置主键 ...
JUC多线程：synchronized锁机制原理 与 Lock锁机制
热门推荐
张维鹏的博客
08-26 1万+
synchronized 通过当前线程持有对象锁，从而拥有访问权限，而其他没有持有当前对象锁的线程无法拥有访问权限，保证在同一时刻，只有一个线程可以执行某个方法或者某个代码块，从而保证线程安全。synchronized 锁机制在 Java 虚拟机中的同步是基于进入和退出监视器锁对象 monitor 实现的
JUC并发编程01——谈谈锁机制：轻量级锁、重量级锁、偏向锁、锁消除与锁优化
半旧518的博客
04-08 806
1.为什么要有并发编程 计算机的cpu与I/O的效率并不是完全一致的，CPU的处理速度快时，在进行I/O操作时，可能会导致CPU空闲的状态，为了最打程度的利用cpu的资源，开发人员创造了并发编程，进程通过轮换可以最大程度的利用cpu的资源，同时给用户进程在同步执行的错觉。但是进程之间并不会共享数据，同时上下文的切换也比较耗时，线程横空出世，同一个进程中的不同线程之间内存共享一片内存区域，线程上下文切换也很轻量级。juc是java官方提供的线程操作的jar包，可以尽可能的降低我们并发编程的难度。 2.锁机制
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值