回归本质，关于锁的8个问题

最新推荐文章于 2022-06-24 20:52:45 发布
最新推荐文章于 2022-06-24 20:52:45 发布
阅读量99 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37437892/article/details/119295122
版权

关于锁的8个问题

1、标准状态下先打印发短信还是打电话

发短信
synchronized锁的是方法的调用者，只有1把锁

package com.ShengChanXiaoFei;

import java.util.concurrent.TimeUnit;

public class EightSuo {
    public static void main(String[] args) throws InterruptedException {


        /*
        *

        * */
        Phone phone1 = new Phone();
//        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendSms();
        }).start();
//此时两个对象不同  两个调用者 两把锁
        TimeUnit.SECONDS.sleep(1);

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

class Phone{

//    synchronized锁的是方法的调用者
//    static 类一加载的时候就有了，锁的是class
//    类的class对象是唯一的


//    静态同步方法
    public  synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }


//    普通同步方法
    public  synchronized void call(){
        System.out.println("打电话");
    }



}

在这里插入图片描述

2.在发短信时不设置延迟4秒也是和情况1一样的结果

3 增加了一个普通方法后，先执行发短信还是hello

本代码先执行hello

package com.ShengChanXiaoFei;

import java.util.concurrent.TimeUnit;

public class EightSuo {
    public static void main(String[] args) throws InterruptedException {


        /*
        * 3.增加了一个普通方法后，先执行发短信还是hello  因为hello是普通方法
        * */
        Phone phone = new Phone();

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

        TimeUnit.SECONDS.sleep(1);

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

class Phone{

//    锁的对象的方法的调用者
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    public void hello(){
        System.out.println("say hello ");
    }
}

在这里插入图片描述

4.两个对象，两个同步方法 发短信还是打电话先打印

package com.ShengChanXiaoFei;

import java.util.concurrent.TimeUnit;

public class EightSuo {
    public static void main(String[] args) throws InterruptedException {


        /*
        *
        * 4.两个对象，两个同步方法 发短信还是打电话先打印
        * 打电话先
        *
        * */
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendSms();
        }).start();
//此时两个对象不同  两个调用者 两把锁
        TimeUnit.SECONDS.sleep(1);

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

class Phone{

//    锁的对象的方法的调用者  ---->对象实例
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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



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

在这里插入图片描述

5.变为静态同步方法后 发短信还是打电话先打印

package com.ShengChanXiaoFei;

import java.util.concurrent.TimeUnit;

public class EightSuo {
    public static void main(String[] args) throws InterruptedException {


        /*
        *
        * 5.变为静态同步方法后 发短信还是打电话先打印
        * 发短信先
        *
        * */
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendSms();
        }).start();
//此时两个对象不同  两个调用者 两把锁
        TimeUnit.SECONDS.sleep(1);

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

class Phone{

//    synchronized锁的是方法的调用者
//    static 类一加载的时候就有了，锁的是class
//    类的class对象是唯一的
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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



}

在这里插入图片描述

6 变为静态同步方法后，使用两个对象， 发短信还是打电话先打印？

package com.ShengChanXiaoFei;

import java.util.concurrent.TimeUnit;

public class EightSuo {
    public static void main(String[] args) throws InterruptedException {


        /*
        *
        * 6.变为静态同步方法后，使用两个对象， 发短信还是打电话先打印？
        * 发短信先
        *
        * */
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendSms();
        }).start();
//此时两个对象不同  两个调用者 两把锁
        TimeUnit.SECONDS.sleep(1);

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

class Phone{

//    synchronized锁的是方法的调用者
//    static 类一加载的时候就有了，锁的是class
//    类的class对象是唯一的
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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



}

在这里插入图片描述

7、一个对象，普通同步方法和一个静态同步方法？ 此时先打印哪个

打电话先打印
for 静态同步方法锁的是类的class对象（唯一） 普通同步方法锁的是类的实例
此时有两把锁

package com.ShengChanXiaoFei;

import java.util.concurrent.TimeUnit;

public class EightSuo {
    public static void main(String[] args) throws InterruptedException {


        /*
        *
        * 6.一个对象，普通同步方法和一个静态同步方法？ 此时先打印哪个
        *打电话先
        * */
        Phone phone1 = new Phone();
//        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendSms();
        }).start();
//此时两个对象不同  两个调用者 两把锁
        TimeUnit.SECONDS.sleep(1);

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

class Phone{

//    synchronized锁的是方法的调用者
//    static 类一加载的时候就有了，锁的是class
//    类的class对象是唯一的


//    静态同步方法
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }


//    普通同步方法
    public  synchronized void call(){
        System.out.println("打电话");
    }



}

8 两个对象，普通同步方法和一个静态同步方法？ 此时先打印哪个?

打电话先
原理同7

package com.ShengChanXiaoFei;

import java.util.concurrent.TimeUnit;

public class EightSuo {
    public static void main(String[] args) throws InterruptedException {


        /*
        *
        * 8.两个对象，普通同步方法和一个静态同步方法？ 此时先打印哪个
        *打电话先
        * 原理同7
        * */
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendSms();
        }).start();
//此时两个对象不同  两个调用者 两把锁
        TimeUnit.SECONDS.sleep(1);

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

class Phone{

//    synchronized锁的是方法的调用者
//    static 类一加载的时候就有了，锁的是class
//    类的class对象是唯一的


//    静态同步方法
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }


//    普通同步方法
    public  synchronized void call(){
        System.out.println("打电话");
    }



}
爱学习的羽
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
模型选择问题
01-20
在模型选择过程中，我们通常会遇到两个主要问题：欠拟合和过拟合。 欠拟合（Underfitting）是指模型过于简单，无法捕捉到数据集中的复杂关系。这可能是由于模型的假设过于严格，或者特征选择不足导致的。解决欠拟合...
锁的问题总结
baidu_38176716的博客
12-26 171
所有的锁都有性能消耗，高并发下，锁带来上下文切换，资源同步等消耗非常可观。，线程在锁上消耗比线程本身还多，应该尽可能少用锁，如果不可避免，那就用非阻塞算法解决问题，但不是绝对的。 内部锁： java通过synchronized保持原子性，独占锁，锁请求互斥，跟高级锁（Lock/ReadWriteLock），synchronized简单，lock必须在finally代码里用，Lock的资源已经用到了...
各类锁问题
weixin_55166254的博客
06-24 129
对锁都知识点进行总结
锁的问题
sclw0488的专栏
01-17 816
现在老是出现这样的错误提示!-2147467259 Your transaction(process ID #30) was deadlocked with another process and has been chosen as the deadlock victim.Return your transaction.use master gocreate proc killspid
1 JUC（高并发）
wang_luwei的博客
10-06 738
文章目录1.什么是JUC2.进程和线程3.并发与并行4.线程的状态（六个）5.wait/sleep的区别6.Lock锁与Synchronized（重点）6.1传统的Synchronized （关键字）6.2lock锁 （lock是一个接口）6.2.1 ReentrantLock 可重入锁中的公平锁与非公平锁6.2.2 与6.1不同的加锁方式的买票案例6.3Synchronized 和 Lock区别7.生产者与消费者问题（线程通信）7.1传统版本，用Synchronized实现的7.1.1存在的问题(虚假唤醒
SQL Server死锁总结
weixin_30545285的博客
05-17 880
SQL Server死锁总结 1. 死锁原理 根据操作系统中的定义：死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所站用不会释放的资源而处于的一种永久等待状态。 死锁的四个必要条件：互斥条件(Mutual exclusion)：资源不能被共享，只能由一个进程使用。请求与保持条件(Hold and wait)：已经得到资源的进程...
ruby开源社区软件 Rabel.zip
07-17
Rabel 是新一代开源社区软件，设计简洁，摒弃了传统论坛软件的臃肿功能，让论坛回归交流本质。 如果你厌倦了discuz!/phpwind，不妨试试 Rabel ！ 标签：开源社区 论坛社区 开源论坛
数学建模数学建模简介PPT学习教案.pptx
10-08
简单地说：就是系统的某种特征的本质的数学表达式（或是用数学术语对部分现实世界的描述），即用数学式子（如函数、图形、代数方程、微分方程、积分方程、差分方程等）来描述（表述、模拟）所研究的客观对象或系统在...
福建省华安龙海_高二语文上学期第一次联考试题.doc
11-18
3. 马小菊的故事虽未直接涉及“牢笼”或“生存困境”，但它提供了一个情境，即人们在面对生活中的困难时，可能会寻找内心的慰藉或逃离现实的压力。马小菊冒雨前往药店，可以象征着在生活困境中寻求解决之道的过程，...
江西省南昌十九中奉新一中安义中学2015_2016学年高二语文上学期第一次联考试题
08-06
这暗示着在面对现代生存困境时，可能需要回归到更本质的生活方式和价值观。 通过对“牢笼”一词的理解，我们可以看到，无论是在物质层面还是精神层面，现代人都面临着被束缚的困境。试题中的选择题部分，第一题强调...
8锁，就是关于锁的8个问题
weixin_45752694的博客
09-17 261
synchronized 锁的对象是方法的调用者,经过8锁问题能更加理解这个概念
多线程(三)关于锁的8个问题
sand_wich的博客
08-02 225
目录1、标准情况下，两个线程先打印哪个2、sendSms延迟四秒，执行顺序3、增加一个普通方法后，先发短信还是先hello；4、两个对象，两个同步方法，发短信还是打电话5.增加两个静态的同步方法6、两个对象，增加两个静态的同步方法7、一个静态同步方法，一个普通同步方法，先打印谁8、一个静态同同步方法，一个普通同步方法，两个对象 1、标准情况下，两个线程先打印哪个 使用synchronized锁 public class Test1 { public static void main(String[]
八皇后 java实现
秀
05-20 2478
回朔法： import java.util.Scanner; public class Main{ public static final int N=100; public static int []queen=new int[N]; public static int n; public static int sum=0; public static void main(Stri...
如何4招解决队列中的线程同步、阻塞问题
秀
08-03 1199
读写锁应用背景 package com.unsafe; import java.util.HashMap; import java.util.Map; public class ReadWriteLockPro { public static void main(String[] args) { MyCache myCache = new MyCache(); for (int i = 1; i <= 6; i++) { final
模拟购物车 java程序
秀
04-21 1184
package pra; import java.awt.Choice; import java.awt.Color; import java.awt.Component; import java.awt.Dimension; import java.awt.FlowLayout; import java.awt.Font; import java.awt.Graphics; import ja...
最大子段和 java
秀
05-20 449
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class Main{ public static void main(String args[]) throws NumberFormatException, IOException { ...
springboot扩展功能
秀
08-17 245
异步任务 package com.zhou.springboot09task.service; import org.springframework.stereotype.Service; import java.util.concurrent.TimeUnit; @Service public class AsyncService { public void hello(){ try { TimeUnit.SECONDS.sleep(3);
docker精通之路（上）
秀
08-25 184
run的运行流程图 docker是怎么工作的 Docker是一个client-server结构的系统，Docker的守护进程运行在主机上，通过socket从客户端访问，server收到client的命令就会执行 Docker为什么比虚拟机快 Docker有着比虚拟机更少的抽象层。由于Docker不需要Hypervisor实现硬件资源虚拟化，运行在Docker容器上的程序直接使用的都是实际物理机的硬件资源。 Docker利用的是宿主机的内核，而不需要Guest OS。因此，当新建一个容器时，Docke
线性回归分析：从简单问题到多元线性回归
多项式回归分析可以看作是一种特殊的多元线性回归问题，其中每个解释变量都可以是多项式形式。 四、线性回归模型的建立 线性回归模型可以通过以下步骤建立： 1. 数据收集：收集训练数据，包括解释变量和响应变量...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值