并发编程中Synchronized锁的七个问题 带你了解锁的究竟是谁

最新推荐文章于 2024-07-04 15:45:43 发布
最新推荐文章于 2024-07-04 15:45:43 发布
阅读量2.5k 收藏 1
点赞数
文章标签： java 线程安全 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43788143/article/details/122584015
版权

锁能锁的东西只有两个，一个是new出来的对象， 另一个是Class模板，因为对象是由Class模板new出来的所以class模板也可以上锁
对象可以有多个，但class模板只有一个

1.执行下面这段代码，那个方法会先执行？

import java.util.concurrent.TimeUnit;

/**
 * @Author : chenjianbo
 * @Data : 2022/1/19 16:14
 */
public class SynchronizedTest {
    public  synchronized  void  eat(){
        System.out.println("猫在吃东西");

    }
    public  synchronized  void  sleep(){
        System.out.println("猫在睡觉");
    }

	//主方法
    public static void main(String[] args) throws InterruptedException {
        SynchronizedTest cat = new  SynchronizedTest();
        //启动线程执行cat类的方法
        new Thread(()->{
            //执行方法
            cat.eat();
        },"A").start();
		//执行完A线程以后 主线程睡眠几秒后在执行B线程
        TimeUnit.SECONDS.sleep(2);
        //启动线程执行cat类的方法
        new Thread(()->{
            cat.sleep();
        },"B").start();
    }
}

答：Synchronized锁的是方法的调用者也就是 cat这个实例。因为这两个线程调用的是同一个实例的方法，所以谁先调用谁就获得锁。
在这里插入图片描述
2.在线程中加入睡眠，输出的结果又是怎样

import java.util.concurrent.TimeUnit;

/**
 * @Author : chenjianbo
 * @Data : 2022/1/19 16:14
 */
public class SynchronizedTest {
    public  synchronized  void  eat(){
        System.out.println("猫在吃东西");

    }
    public  synchronized  void  sleep(){
        System.out.println("猫在睡觉");
    }


    public static void main(String[] args) throws InterruptedException {
        SynchronizedTest cat = new  SynchronizedTest();
        //启动线程执行cat类的方法
        new Thread(()->{
            //睡眠
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //执行方法
            cat.eat();
        },"A").start();
        //执行完A线程以后 主线程睡眠几秒后在执行B线程
        TimeUnit.SECONDS.sleep(2);
        //启动线程执行cat类的方法
        new Thread(()->{
            cat.sleep();
        },"B").start();
    }
}

答： 因为线程中睡眠的时间 超过了主线程中的睡眠时间，导致线程B中的sleep（）方法首先获得了锁。在这里插入图片描述
3.在eat()方法中加入睡眠，输出的结果又是怎样

import java.util.concurrent.TimeUnit;

/**
 * @Author : chenjianbo
 * @Data : 2022/1/19 16:14
 */
public class SynchronizedTest {
    public  synchronized  void  eat(){
        //睡眠
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("猫在吃东西");

    }
    public  synchronized  void  sleep(){
        System.out.println("猫在睡觉");
    }


    public static void main(String[] args) throws InterruptedException {
        SynchronizedTest cat = new  SynchronizedTest();
        //启动线程执行cat类的方法
        new Thread(()->{
            //执行方法
            cat.eat();
        },"A").start();
         //执行完A线程以后 主线程睡眠几秒后在执行B线程
        TimeUnit.SECONDS.sleep(2);
        //启动线程执行cat类的方法
        new Thread(()->{
            cat.sleep();
        },"B").start();
    }

}

答：虽然eat()方法中有睡眠 但还是eat()方法先获得了锁，只有等eat()方法执行完 另一个方法才能获取到锁
在这里插入图片描述

4.把sleep()方法改成普通类，不再用synchronized修饰，结果会怎样

import java.util.concurrent.TimeUnit;

/**
 * @Author : chenjianbo
 * @Data : 2022/1/19 16:14
 */
public class SynchronizedTest {
    public  synchronized  void  eat(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("猫在吃东西");

    }
    public   void  sleep(){
        System.out.println("猫在睡觉");
    }


    public static void main(String[] args) throws InterruptedException {
        SynchronizedTest cat = new  SynchronizedTest();
        //启动线程执行cat类的方法
        new Thread(()->{
            //执行方法
            cat.eat();
        },"A").start();
        //执行完A线程以后 主线程睡眠几秒后在执行B线程
        TimeUnit.SECONDS.sleep(2);
        //启动线程执行cat类的方法
        new Thread(()->{
            cat.sleep();
        },"B").start();
    }

}

答：因为sleep()方法是普通类没有锁，不受锁的影响，那么这两个线程之间没有关系，各自运行。但因为eat()方法中有睡眠，且大于主线程中的睡眠时间，所以线程B中的内容会先输出来
在这里插入图片描述
5.实例化两个类，两个同步方法，结果又如何？

import java.util.concurrent.TimeUnit;

/**
 * @Author : chenjianbo
 * @Data : 2022/1/19 16:14
 */
public class SynchronizedTest {
    public  synchronized  void  eat(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("猫在吃东西");

    }
    public  synchronized  void  sleep(){
        System.out.println("猫在睡觉");
    }


    public static void main(String[] args) throws InterruptedException {
        SynchronizedTest cat = new  SynchronizedTest();
        SynchronizedTest cat2 = new  SynchronizedTest();
        //启动线程执行cat类的方法
        new Thread(()->{
            //执行方法
            cat.eat();
        },"A").start();
        //执行完A线程以后 主线程睡眠几秒后在执行B线程
        TimeUnit.SECONDS.sleep(2);
        //启动线程执行cat类的方法
        new Thread(()->{
            cat2.sleep();
        },"B").start();
    }
}

答：因为是两个实例化的对象，锁的是各自的对象，也就是有两把锁，两个线程之间没有联系，因为A线程中eat()方法中的睡眠时间大于主线程中的睡眠时间，所以B线程中的内容会先输出出来
在这里插入图片描述
6.把两个方法变成静态方法，那结果又该如何

import java.util.concurrent.TimeUnit;

/**
 * @Author : chenjianbo
 * @Data : 2022/1/19 16:14
 */
public class SynchronizedTest {
    public static synchronized  void  eat(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("猫在吃东西");

    }
    public static synchronized  void  sleep(){
        System.out.println("猫在睡觉");
    }


    public static void main(String[] args) throws InterruptedException {
        //启动线程执行cat类的方法
        new Thread(()->{
            //执行方法
            SynchronizedTest.eat();
        },"A").start();
        //执行完A线程以后 主线程睡眠几秒后在执行B线程
        TimeUnit.SECONDS.sleep(2);
        //启动线程执行cat类的方法
        new Thread(()->{
            SynchronizedTest.sleep();
        },"B").start();
    }



}

回答：静态方法在类加载的时候就已经生成了，所以synchronized锁的不再是对象 而是Class模板,因为Class模板只有一个所以这两个方法用的是同一个锁，所以谁先获取到锁就先执行谁。
在这里插入图片描述
7.一个设置成静态方法，一个同步方法，结果如何

import java.util.concurrent.TimeUnit;

/**
 * @Author : chenjianbo
 * @Data : 2022/1/19 16:14
 */
public class SynchronizedTest {
    public static synchronized  void  eat(){
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("猫在吃东西");

    }
    public  synchronized  void  sleep(){
        System.out.println("猫在睡觉");
    }


    public static void main(String[] args) throws InterruptedException {
        SynchronizedTest cat = new  SynchronizedTest();

        //启动线程执行cat类的方法
        new Thread(()->{
            //执行方法
            SynchronizedTest.eat();
        },"A").start();
        //执行完A线程以后 主线程睡眠几秒后在执行B线程
        TimeUnit.SECONDS.sleep(2);
        //启动线程执行cat类的方法
        new Thread(()->{
            cat.sleep();
        },"B").start();
    }



}

答：static synchronized 锁的是对象，synchronized 锁的是Class模板，两者锁的东西不一样即有两个锁，两个线程之间没有关系，虽然A线程中的方法有睡眠 但睡眠时间短于主线程睡眠的时间，所以A线程的内容会先输出出来。
在这里插入图片描述

辰溪0502
关注
关于synchronized使用的问题汇总
02-16 902
错1：在@Transactional方法上加入synchronized关键字场景:解释：处理方法： 因为是逐步积累，所以一开始遇到的问题也不会很多。 错1：在@Transactional方法上加入synchronized关键字 场景: 写法如下，刚开始遇到时不懂，后来因为前段处理不当，到后台有几率必定出现多次重复请求，才发现使用了synchronized无效 @Service class Ga...
并发编程下的锁机制，乐观锁、悲观锁、共享锁、排他锁、分布式锁、锁降级原理篇
12-21
在并发编程中，锁机制是控制多线程访问共享资源的一种重要方式，它确保了并发环境下的数据一致性。本文将详细讲解几种常见的锁机制：悲观锁、乐观锁、共享锁和排他锁，并简要介绍分布式锁以及锁降级原理。 1. **...
synchronized到底锁的是谁
然而老干妈早就看穿了一切
04-26 169
举例： public class Data { public static void main(String[] args) { Test test=new Test(); //线程A new Thread(()->{ test.eat(); },"A").start(); try{ TimeUnit.SECONDS.sleep(1);
synchronized到底锁的是谁？
超级氯化钾的博客
10-15 580
synchronized实现线程同步，让多个线程排队以此获取某个资源，保证数据不会出错。
Synchronized到底锁住的是谁？
weixin_33874713的博客
06-19 178
先来一道并发编程笔试题 题目：利用5个线程并发执行，num数字累计计数到10000，并打印。 /** * Description: * 利用5个线程并发执行，num数字累加计数到10000，并打印。 * 2019-06-13 * Created with OKevin. */ public class Count { private int num = 0; public stati...
synchronized你到底锁住的是谁？
NWPU_LIUBO的博客
11-28 213
synchronized你到底锁住的是谁？ synchronized从语法的维度一共有3个用法： 1.静态方法加上关键字 2.实例方法（也就是普通方法）加上关键字 3.方法中使用同步代码块 synchronized从锁的是谁的维度一共有两种情况： 1.锁住类 2.锁住对象实例 我们还是从直观的语法结构上来讲述synchronized。 1）静态方法上的锁 静态方法是属于“类”，不属于某个...
Java并发 synchronized锁住的内容解析
08-25
Java并发synchronized锁住的内容解析是Java并发编程中的一种重要机制，用于解决多线程并发访问同一个资源时可能出现的线程安全问题。通过使用synchronized关键字，可以锁住当前对象的当前方法，使得其他线程访问该...
并发编程Synchronized锁
Chasel_s的博客
09-14 138
补充知识： 操作锁的原理有两种方式： 通过在内存上阻止多线程对对象的获取 在指令集上阻止多线程对指令的执行 Java中的每个对象都有一个monitor对象，加锁就是在竞争monitor对象，对代码块加锁是通过在指令前后添加monitorenter和monitorexit 指令实现的。 Synchronized 主要通过操作对象的monitor对象来实现锁的 synchronized 作用于成员变量和非静态方法时，锁住的是对象实例 synchronized 作用于静态方法时，锁住.
Java 并发编程学习笔记之Synchronized简介
09-02
Java并发编程中的Synchronized关键字是Java提供的一种内置锁机制，用于解决多线程环境下的线程安全问题。在Java中，线程安全意味着多个线程访问同一份资源时，能够保持数据的一致性和完整性，避免数据冲突。...
并发编程三（synchronized锁）
baidu_32689899的博客
06-15 176
1，举个例子 创建两个线程来给count变量的值做自增操作，每个线程加1000次 我们期望得到count的值应该是2000 public class SyncDemo { public static int count = 0; public static void main(String[] args) throws InterruptedException { // 创建两个线程来给count变量的值做自增操作，每个线程加1000次 // 我们预期
synchronized锁住的到底是谁？
qq_41710400的博客
08-18 216
我看了下面一位博主的博客，感觉讲解的很详细，转载过来收藏 https://www.cnblogs.com/yulinfeng/p/11020576.html
synchronized到底锁住的是谁？
06-19 150
题目：利用5个线程并发执行，num数字累计计数到10000，并打印。 1 /** 2 * Description: 3 * 利用5个线程并发执行，num数字累加计数到10000，并打印。 4 * 2019-06-13 5 * Created with OKevin. 6 ...
synchronized锁的8个问题
qq_38307826的博客
06-29 296
关于synochronized的八个问题 1 标准访问，先打印短信还是邮件 短信 class Phone { public synchronized void sendSMS() throws Exception { System.out.println("------sendSMS"); } public synchronized void sendEmail() throws Exception { Syst
synchronized 到底锁的是谁？
pingfanblog
11-05 351
synchronized 到底锁的是谁？修饰方法：1、静态方法2、非静态方法，锁住的是方法的调用者修饰代码块。
synchronized 锁谁的问题
weixin_44089714的博客
09-27 103
转暂：https://www.cnblogs.com/yulinfeng/p/11020576.html 讲的很棒
Java并发编程系列- synchronized
06-16
在Java编程语言中，`synchronized`关键字是并发编程中的关键概念，它用于控制多线程对共享资源的访问，以避免数据不一致性和线程安全问题。本篇文章将深入探讨`synchronized`的使用及其在Java并发编程中的作用。 ...
并发编程中的Synchronized锁详解
最新发布
qq_39701205的博客
07-04 614
重量级锁对象的实现，采用C++ 编写，在Synchronized 同步的对象的对象头MarkWord中指针指向这个真正的对象。第三部分：填充字符，因为虚拟机要求对象字节必须是8字节的整数倍，填充字符就是用于凑齐这个整数倍的。第二部分：实例变量存储的是对象的属性信息，包括父类的属性信息，按照4字节对齐。Synchronized 的锁存在锁对象的对象头MarkWord中。第一部分：对象头，主要包括。由图中可用得出两个结论。
synchronized细节问题
eric的博客
12-31 263
synchronized
synchronized锁住的到底是谁？？？
qq_60264381的博客
05-06 698
类声明后，new出来的实例对象，在堆中都有自己的独立空间和引用地址，这时候我们可以认为这些实例都是。而静态成员(static修饰的成员、方法)是跟类一起加载的，也是存放在方法区，被所有线程共享。在静态方法上进行了声明则锁的是这个类，也就是我们常说的。，所以在实例上加的锁与其它的实例就没有关系，互不影响。从锁的是谁的纬度上一共有两种情况；的，所以类也是被所有线程共享的。类信息是存放在方法区的，整个JVM中只有一份。
Jvm: synchronized锁定谁？
amadeus_liu2的博客
08-05 166
jvm
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

辰溪0502

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值