9、JUC:八锁现象彻底理解锁

最新推荐文章于 2022-02-07 21:55:35 发布
最新推荐文章于 2022-02-07 21:55:35 发布
阅读量233 收藏
点赞数
分类专栏： JUC并发编程 文章标签： JUC 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41347385/article/details/109862669
版权

学习过程观看视频：[狂神说Java]
https://www.bilibili.com/video/BV1B7411L7tE?p=10
欢迎大家支持噢，很良心的老师了！

现象1：先打印发短信，还是打电话？

java代码

package com.zjl;

import java.util.concurrent.TimeUnit;

/**
 * Created by zjl
 * 2020/11/20
 **/
public class Test4 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sendSms();
        },"A").start();

        new Thread(()->{
            phone.call();
        },"B").start();
    }

}

class Phone{

    public synchronized void sendSms(){
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

}

运行截图

在这里插入图片描述

解释：

synchronized锁的是对象的调用者，调用两个方法的都是同一个对象phone，也就是用的同一个锁，当一个方法占用此对象锁时，只有这个方法执行完才会释放锁。

现象2

package com.zjl;

import java.util.concurrent.TimeUnit;

/**
 * Created by zjl
 * 2020/11/20
 **/
public class Test4 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
            System.out.println("1秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(()->{
            phone.call();
        },"B").start();
    }

}

class Phone{

    public synchronized void sendSms(){   //加锁
        try {
            TimeUnit.SECONDS.sleep(4);
            System.out.println("4秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){   //加锁
        System.out.println("打电话");
    }

}

运行截图：

在这里插入图片描述

解释：

synchronized锁的是对象的调用者，调用两个方法的都是同一个对象phone，也就是用的同一个锁，当一个方法占用此对象锁时，只有这个方法执行完才会释放锁，也就是先占用锁的先执行完毕，才能其他人占用锁。

现象3：增加一个普通方法，先输出发短信还是hello？

package com.zjl;

import java.util.concurrent.TimeUnit;

/**
 * Created by zjl
 * 2020/11/20
 **/
public class Test5 {
    public static void main(String[] args) {
        Phone5 phone = new Phone5();

        new Thread(()->{
            phone.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
            System.out.println("1秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.hello();
        },"B").start();
    }

}

class Phone5{

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
            System.out.println("4秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public void hello(){
        System.out.println("hello");
    }

}

运行截图：

在这里插入图片描述

解释：

hello方法没有用synchronized来修饰，所以phone对象锁被其他线程占用的话，也不影响自身线程的执行。

现象4：两个对象，两个被synchronized修饰的方法，先输出发短信还是打电话？

package com.zjl;

import java.util.concurrent.TimeUnit;

/**
 * Created by zjl
 * 2020/11/20
 **/
public class Test6 {
    public static void main(String[] args) {
        Phone6 phone1 = new Phone6();
        Phone6 phone2 = new Phone6();

        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
            System.out.println("1秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }

}

class Phone6{

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
            System.out.println("4秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

}

运行截图：

在这里插入图片描述

解释

因为synchronized锁的是方法的调用者，此题中是两个对象，所以两个方法的调用时不受彼此的影响，各自执行各自的，注意，两个地方的线程睡眠，这里看清楚，就明白为什么先打电话，再发短信了。

现象5：一个对象，两个静态方法，先打印发短信，还是打电话？

package com.zjl;

import java.util.concurrent.TimeUnit;

/**
 * Created by zjl
 * 2020/11/20
 **/
public class Test7 {
    public static void main(String[] args) {
        Phone7 phone1 = new Phone7();

        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
            System.out.println("1秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone1.call();
        },"B").start();
    }

}

class Phone7{

    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
            System.out.println("4秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }

}

执行结果：

在这里插入图片描述

解释：

static修饰了的两个synchronized方法，此时锁的并不是方法的调用者phone对象，因为staic静态方法，类一加载就有了，实际上锁的是phone对象的class文件，也就是锁的是phone对象的class模板，而且class模板只有一份，所以执行的时候，先拿到锁的先执行，执行完，其他才能执行。

现象6：两个对象，两个静态同步方法，先打印发短信，还是打电话？

package com.zjl;

import java.util.concurrent.TimeUnit;

/**
 * Created by zjl
 * 2020/11/20
 **/
public class Test7 {
    public static void main(String[] args) {
        Phone7 phone1 = new Phone7();
        Phone7 phone2 = new Phone7();

        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
            System.out.println("1秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }

}

class Phone7{

    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
            System.out.println("4秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }

}

执行结果：

在这里插入图片描述

解释：

同现象5解释一致。
static修饰了的两个synchronized方法，此时锁的并不是方法的调用者phone对象，因为staic静态方法，类一加载就有了，实际上锁的是phone对象的class文件，也就是锁的是phone对象的class模板，而且class模板只有一份，所以执行的时候，先拿到锁的先执行，执行完，其他才能执行。

现象7：一个对象，一个静态同步方法，一个普通同步方法，先打印发短信，还是打电话？

package com.zjl;

import java.util.concurrent.TimeUnit;

/**
 * Created by zjl
 * 2020/11/20
 **/
public class Test7 {
    public static void main(String[] args) {
        Phone7 phone1 = new Phone7();

        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
            System.out.println("1秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone1.call();
        },"B").start();
    }

}

class Phone7{

    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
            System.out.println("4秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

}

输出结果：

在这里插入图片描述

解释：

synchronized一个锁的是对象，一个锁的是的class类模板，所以两个同步方法锁的并不是同一个东西，所以执行过程中互不影响，注意，两个地方的线程睡眠，这里看清楚，就明白为什么先打电话，再发短信了。

现象8：两个对象，一个静态同步方法，一个普通同步方法，先打印发短信，还是打电话？

package com.zjl;

import java.util.concurrent.TimeUnit;

/**
 * Created by zjl
 * 2020/11/20
 **/
public class Test7 {
    public static void main(String[] args) {
        Phone7 phone1 = new Phone7();
        Phone7 phone2 = new Phone7();

        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
            System.out.println("1秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }

}

class Phone7{

    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
            System.out.println("4秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

}

执行结果：

在这里插入图片描述

解释：

因为是两个对象，而且一个是静态同步方法，一个是普通同步方法，一个锁的是对象，一个锁的是class模板，所以锁的并不是同一个东西，所以执行过程中互不影响，注意，两个地方的线程睡眠，这里看清楚，就明白为什么先打电话，再发短信了。

小结：

锁的东西无非两种：
1、锁new出来的对象，这种对象是独立的，锁不同对象时是互不影响的。
2、锁class类模板，每个对象类只有一个class类模板。

@Eleven
关注
专栏目录
synchronized锁的是什么？
03-11 1173
https://www.cnblogs.com/keita/p/8583281.html synchronized是java中并发编程最重要的关键字之一。如果没搞清楚synchronized锁的是什么，可能导致用了没效果，没控制住并发访问 synchronized常用的方式有以下四种 public class SyncTest{ publicsynchronizedvoi...
面试部分难点梳理 - MySQL 索引 + 隔离 + 锁 与 JUC
paleatta的博客
03-21 862
Java中断模型 MySQL 一次最多读取16KB，也就是最多读取32个扇区，一个扇区512B。 一个B+树的每个节点最多只有16KB。 聚集索引和非聚集索引 如果主键被定义了，那么这个主键就是以恶个聚集索引。 如果没有主键被定义，那么数据库会寻找第一个唯一非空的属性作为聚集索引。 如果没有主键也没有适合的唯一索引，那么InnoDB会生成一个隐藏的主键作为聚集索引，这个主键是一个6个字节的列，改列的值会随着数据的插入而自增。 自增主键会把数据自动向后插入，避免了插入过程中的聚集索引排序的问题，聚集索
理解一下synchronized锁的是什么
Hai-Yang-code的博客
07-06 344
package com.qcby.lock; import java.util.concurrent.TimeUnit; /** * @author HuangHaiyang * @date 2020/07/06 * @description: description * @version: 1.0.0 */ /** * @Date: 2020/7/6 * 两个普通同步方法 发短信 打电话 * @return: */ public class SyncTest { pu
Java synchronized到底锁住的是什么？
weixin_34242331的博客
07-25 182
使用环境：多线程java程序中。 作用：在多线程的环境下，控制synchronized代码段不被多个线程同时执行。synchronized既可以加在一段代码上，也可以加在方法上。 使用：synchronized锁住的是括号里的对象，而不是代码。对于非static的synchronized方法，锁的就是对象本身也就是this。 通过以下两个案例说明： //包含了synchronized ...
【线程】synchronized锁的是什么
Elephant_King的博客
02-07 2784
1.synchronized作用于成员变量和非静态方法时，锁住的是对象的实力，即this对象 2.synchronized作用于静态方法时，锁住的是Class实例 3.synchronized作用于一个代码块时，锁住的是所有代码块中配置的对象 ...
JUC详解
热门推荐
weixin_42998267的博客
04-07 1万+
1.什么是JUC(面试高频) java.util工具包、包、分类 业务：普通的线程代码 Thread Runnable 没有返回值、效率相比于Callable相对较低 2.线程和进程 进程：一个程序，QQ.exe Music.exe 程序的集合； 一个进程往往可以包含多个线程，至少包含一个！ java默认有几个线程？2个线程 main线程、GC线程 线程：开了一个进程Typora，写字，自动...
新手通俗易懂的juc优质文章
元空间
04-22 234
JUC 并发编程 学习方法，学习新知识 要结合以前得旧知识 再结合实战 组成新知识 体系知识 文章目录JUC 并发编程1.什么是juc2.线程和进程与锁线程有几个状态wait和sleep区别lock锁（重点）lock锁与synchronized锁区别什么是锁 如何判断锁是谁生产者与消费者问题JUC版本生产者消费者关系**8锁概念**静态方法 锁得概念集合类不安全COPYONWRITEARRAYLIST(LIST不安全)SET不安全Map（不安全）Callable（easy）三大常用辅助类countDownL
JUC进阶详细笔记
qq_44619964的博客
04-21 1920
多线程进阶-JUC并发 文章目录**多线程进阶-JUC并发****1、搭建基础环境****2、什么是JUC****3、线程和进程****并发编程：并发、并行****并发编程的本质：充分利用CPU的资源****线程有几个状态****wait/sleep区别****4、Lock锁(重点)****传统的Synchronized****Lock接口**公平锁：非公平锁：Synchronized和Lock锁...
Java之JUC
lyw4631的博客
11-02 904
文章目录前置要求线程基础知识复习Futrue和Callable接口从之前的FutureTask说对Future的改进案例精讲-从电商网站的比价需求说CompletableFutrue常用方法CompletableFutrue说说Java"锁"事LockSupport与线程中断Java内存模型值JMMvolatile与Java内存模型 前置要求 线程基础知识复习 Futrue和Callable接口 从之前的FutureTask说 对Future的改进 案例精讲-从电商网站的比价需求说 CompletableF
synchronized锁的是什么
一枚野生程序员 —— Tim
03-28 1605
最近发现synchronized锁的是什么？甚至有人认为synchronized锁的是代码？？！这个我觉得还是很有必要通过实际的示例来说明synchronized锁的到底是什么。 根据获取的锁的分类：获取对象锁和获取类锁！ 获取对象锁的两种用法 1、同步代码块(synchronized(this), synchronized(类实例对象))，锁是小括号()中的实例对象。2...
synchronized锁的到底是什么？
qq_33999844的博客
06-16 358
1.起源于一个问题 场景一：线程安全吗？ static String lock1 = new String("aaa"); static String lock2 = new String("bbb"); public static void test3(){ synchronized (lock1) { // 业务代码会被锁住吗？ lock1 = lock1 + "x"; i++; } }
synchronized锁住的是什么
qq_36583047的博客
12-25 300
一  synchronized修饰函数时，同一对象中的带有synchronized的函数不能同时运行 二  synchronized修饰代码块时，锁的是 用同一个对象做为锁的代码块 这些代码块不能同时运行 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public
synchronized锁住的是什么？
weixin_45097458的博客
11-27 252
对象锁：同步方法锁住的是对象 A.一个对象+有多个synchronized方法：某一时刻内，只要有一个线程去调用其中一个synchronized 方法，其他的线程都要等待。 B.一个对象中+synchronized方法+非synchronized方法：某个线程访问同步方法不影响其他线程访问非同步方法 C.多个对象+多个同步方法：访问不同的对象的同步方法不会相互影响 全局锁：静态同步方法锁的是当前的...
Java的synchronized锁的到底是什么？
笨鸟贤妃的博客
05-22 705
synchronized被大大小小的程序员广泛使用，有的程序员偷懒，在要求保证线程安全时，不加思索的就在方法前加入了synchronized关键字（例如我刚才那道校招级大题）。偷懒归偷懒，CodeReview总是要进行的，面对同事的“指责”，要求优化这个方法，将synchronized使用同步代码块的方式提高效率。 synchronized要按照同步代码块来保证线程安全，这可就加在方法“复杂”多了。有：synchronized(this){}这么写的，也有synchronized(Count.class)
Synchronized() 锁的的到底是啥？
LRBrZero的博客
04-28 224
同步方法锁的是当前实例对象： 同步方法块：锁的也是 -->test 运行结果同上 private void method2(){ synchronized (this){ try { System.out.println("method2"); Thread.sleep(5...
Java中 synchronized到底锁住的是什么？
fct2001140269的博客
04-20 754
Java中 synchronized到底锁住的是什么？ 使用环境：多线程java程序中。 作用：在多线程的环境下，控制synchronized代码段不被多个线程同时执行。synchronized既可以加在一段代码上，也可以加在方法上。 使用：synchronized锁住的是括号里的对象，而不是代码。对于非static的synchronized方法，锁的就是对象本身也就是this。 通过以下三个案例...
synchronized锁住了什么
Lynn
03-17 1万+
先看一个简单示例，下面这段代码能够正常通过编译。 public class SyncTest {     public SyncTest syncVar;     public static SyncTest syncStaticVar;     public static synchronized void testStaticSync() {
对synchronized锁的理解
baidu_23263735的博客
12-10 235
public class MyObject { synchronized public void methodA() { //do something.... } } 在方法前加上synchronized是对象锁，同一对象调用该方法互斥 public class MyObject { static synchronized pub...
Java并发编程：深入理解锁机制与JUC包
Java并发编程中的锁机制是确保...总结来说，Java并发锁机制是设计并行程序的重要工具，理解并熟练运用不同类型的锁以及它们的特点和优势，有助于编写高效、可靠的并发代码。掌握这些概念对于处理复杂并发问题至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值