八锁现象——synchronized关键字

最新推荐文章于 2024-07-14 22:18:32 发布
最新推荐文章于 2024-07-14 22:18:32 发布
阅读量94 收藏
点赞数 1
分类专栏： 多线程 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lljddddd/article/details/134120479
版权

八锁现象——synchronized关键字

学习目标： 什么是锁？锁是什么？如何判断锁的是谁？

八种锁

1、一个对象，俩个同步方法

2、一个对象，俩个同步方法，一个方法延迟

3、两个对象，两个同步方法

4、一个对象，一个同步，一个普通方法

5、一个对象，俩个静态同步方法

6、两个对象，俩个静态同步方法

7、一个对象，一个静态的同步方法，一个同步方法

8、两个对象，一个静态的同步方法，一个同步方法

第一锁

两个线程调用Phone执行Phone下的发短信和打电话方法

1、标准情况下，两个线程先执行发短信，再打电话。

结果：发短信先执行

import java.util.concurrent.TimeUnit;

/**
 * 八锁，就是关于锁的八个问题
 * 1、标准情况下，两个线程先执行发短信，再打电话
 */
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        // 线程A发短信
        new Thread(()->{phone.sendSms();},"A").start();
        // 休息一秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 线程B打电话
        new Thread(()->{phone.call();},"B").start();
    }
}
class Phone{
    // 发短信
    public synchronized void sendSms(){
        System.out.println("发短信");
    }
    // 打电话
    public synchronized void call(){
        System.out.println("打电话");
    }
}
第二锁

2、sendSms方法延时4秒，仍然是先执行发短信，再打电话。所以我们排除执行顺序是按照线程创建的先后顺序

结果：发短信先执行

import java.util.concurrent.TimeUnit;

/**
 * 八锁，就是关于锁的八个问题
 * 2、sendSms方法延时4秒，仍然是先执行发短信，再打电话
 */
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        // 线程A发短信
        new Thread(()->{phone.sendSms();},"A").start();
        // 休息一秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 线程B打电话
        new Thread(()->{phone.call();},"B").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("打电话");
    }
}
第一、二锁解释
被synchronized修饰的方法，锁的对象是方法的调用者，此方法中均是对象Phone来调用的，即两个方法调用的对象是同一个、使用的同一把锁，谁先拿到就谁先执行。

第三锁

3、phone、phone1两个不同对象在两个线程A、B里分别调用发短信、打电话，其中发短信方法有4秒休眠。

结果：打电话先执行

import java.util.concurrent.TimeUnit;

/**
也可以使用Phone phone = new Phone();Phone phone2 = new Phone();phone在线程A中调用发短信，phone2在线程B中调用打电话，这里锁的是两个不同的调用者，所以他们是两把锁，所以互不影响，因为发短信中有4秒的线程休眠，故而一定是打电话被先调用
 */
public class Test2 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        Phone2 phone1 = new Phone2();
        /**
         * 被synchronized 修饰的方式和普通方法 先执行sendSms() 还是 hello()
         * 答案： hello()
         *  解释：新增加的这个方法没有 synchronized 修饰，不是同步方法，不受锁的影响！
         */
        // 线程A调用phone发短信
        new Thread(()->{phone.sendSms();},"A").start();
        // 休息一秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 线程B使用phone1调用打电话
        new Thread(()->{phone1.call();},"B").start();
    }
}

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

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

第四锁

4、phone对象在线程A中调用被synchronized修饰的发短信方法 和 在线程B中调用未被synchronized修饰的普通方法hello

结果：hello先执行

import java.util.concurrent.TimeUnit;

        /**
         * 被synchronized 修饰的方法和普通方法 先执行sendSms() 还是 hello()
         * 答案： hello()
         *  解释：新增加的这个方法没有 synchronized 修饰，不是同步方法，不受锁的影响！
         */
public class Test2 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        // 线程A发短信
        new Thread(()->{phone.sendSms();},"A").start();
        // 休息一秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 线程B调用未被synchronized修饰的方法hello()
        new Thread(()->{phone.hello();},"B").start();
    }
}

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

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

    // say hello 没有被锁 也就是说不是同步方法、不受锁的影响，线程会直接把它来执行
    public void hello(){
        System.out.println("hello");
    }
}
第四锁解释
被synchronized 修饰的方法和普通方法 先执行sendSms() 还是 hello()？
答案是hello()解释：新增加的这个方法没有 synchronized 修饰，不是同步方法，不受锁的影响！

第五锁

5、Phone3在线程A 和 线程B中分别调用Phone3的被synchronized和static修饰的静态同步方法 发短信 和 打电话。

结果：发信息先调用

import java.util.concurrent.TimeUnit;

/**
 * 将两个同步方法设置为静态
 */
public class Test3 {
    public static void main(String[] args) {
        // 线程A发短信
        new Thread(()->{Phone3.sendSms();},"A").start();

        // 休息一秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 线程B打电话
        new Thread(()->{Phone3.call();},"B").start();
    }
}

class Phone3{

    /**
     * 在此处我们将 两个同步方法均设为静态方法,此两个方法在类加载是被加载
     * 所以,在此2个同步方法加载时,它们被全局唯一的Phone3.class对象加载,因为此Phone3.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("打电话");
    }
}
第五锁解释
只要方法被 static 修饰，锁的对象就是 Class模板对象,这个则全局唯一！所以说这里是同一个锁，并不是因为synchronized  这里程序会从上往下依次执行

第六锁

6、phone、phone1两个对象来分别调用两个静态同步方法，哪个先执行？

结论：发短信先执行

import java.util.concurrent.TimeUnit;

/**
 */
public class Test3 {
    public static void main(String[] args) {
        // 因为sendSms和call方法均是静态方法,故而Phone3.sendSms()和new Phone3().sendSms()没有区别
        Phone3 phone = new Phone3();
        Phone3 phone1 = new Phone3();
        // 线程A发短信
        new Thread(()->{phone.sendSms();},"A").start();

        // 休息一秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 线程B打电话
        new Thread(()->{phone1.call();},"B").start();
    }
}

class Phone3{

    // 发短信
    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("打电话");
    }
}
第六锁解释
/**
 * 同被static+synchronized 修饰的两个方法，是先发短信还是先打电话()?
 *  答案：发短信
 *  解释：只要方法被 static 修饰，锁的对象就是 Class模板对象,这个则全局唯一，class模板只有一个，即使是phone和phone1不是同以次实例化的对象，但是无论 phone.静态方法() 还是 phone1.静态方法() 它们均相当于Phone.静态方法()
 *  所以说这里是同一个锁，并不是因为synchronized导致。
 */

第七锁

7、被synchronized修饰的普通方法和被synchronized静态方法是先发短信还是先打电话?

结论：先打电话

import java.util.concurrent.TimeUnit;

/**
 */
public class Test3 {
    public static void main(String[] args) {
        // 因为sendSms和call方法均是静态方法,故而Phone3.sendSms()和new Phone3().sendSms()没有区别
        Phone3 phone = new Phone3();

        // 线程A发短信
        new Thread(()->{phone.sendSms();},"A").start();

        // 休息一秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 线程B打电话
        new Thread(()->{phone.call();},"B").start();
    }
}

class Phone3{
    // 发短信
    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("打电话");
    }
}
第七锁解释
/**
 * 被synchronized修饰的普通方法和被synchronized静态方法是先发短信还是先打电话?
 * 答案：打电话
 * 解释：只要被static修饰锁的是class模板, 而synchronized 锁的是调用的对象
 * 这里是两个锁互不影响，按时间先后执行
 */

第八锁

8、phone、phone1两个对象来分别调用被static+synchronized修饰的静态同步方法发短信 和 被synchronized修饰的普通方法打电话，哪个先执行？

结论：随机执行

import java.util.concurrent.TimeUnit;

/**
 */
public class Test3 {
    public static void main(String[] args) {
        // 因为sendSms和call方法均是静态方法,故而Phone3.sendSms()和new Phone3().sendSms()没有区别
        Phone3 phone = new Phone3();
        Phone3 phone1 = new Phone3();

        // 线程A发短信
        new Thread(()->{phone.sendSms();},"A").start();

        // 休息一秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 线程B打电话
        new Thread(()->{phone1.call();},"B").start();
    }
}

class Phone3{
    // 发短信
    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("打电话");
    }
}
第八锁解释
phone、phone1两个对象来分别调用被static+synchronized修饰的静态同步方法发短信 和 被synchronized修饰的普通方法打电话，先执行发短信还是打电话？
答案：打电话
解释： 只要被static 修饰的锁的就是整个class模板
这里一个锁的是class模板 一个锁的是调用者 
所以锁的是两个对象，互不影响，按CPU调度顺序执行
八锁总结
synchronized(Demo.class){
}
和
synchronized(this){
}

1、new this 调用的是这个对象，是一个具体的对象！
2、static class 唯一的一个模板，即Class对象！

synchronized 锁的对象是方法的调用者！

普通同步方法的调用者是类的实例(实例化对象)
静态同步方法的调用者是类的对象(class对象)
吃饭睡觉改BUG.
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
笔记——synchronized关键字
paidaxinga的博客
08-31 75
synchronized关键字1 概述2 使用方法3 synchronized关键字底层优化4 synchronized和ReentrantLock的区别 1 概述 ​ synchronized关金中解决线程之间访问资源的同步性，可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 2 使用方法 ​ **修饰代码块：**即同步代码块，作用的对象是调用这个代码块的对象。即指定加锁对象，对给定的对象加锁，进入同步代码块之前要获得给定的对象的锁。 public class SynchronizedD
Java并发学习笔记（二）——Synchronized关键字与ReetrantLock同步锁
12-20
【Java并发学习笔记（二）——Synchronized关键字与ReentrantLock同步锁】 在Java多线程编程中，确保线程安全是非常重要的。Synchronized关键字和ReentrantLock是两种常见的同步机制，它们都用于保证线程的原子性、...
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1434
synchronized关键字到底锁的是谁？
并发编程——synchronized关键字的使用
每天努力一点点比昨天强一点点
08-12 131
前言 我们一般对共享数据操作的时候，为了达到线程安全我们会使用synchronized关键字去修饰方法或者代码块。那么今天我们就来讲一讲synchronized关键字的使用。 专栏推荐： 并发编程专栏 synchronized的使用 synchronized的使用可以修饰代码块，也可以修饰对象方法，以及静态方法。不过这些修饰的本质实质就只是锁的资源不同，一种是对象，一种是类。 修饰代码块 错误代码:this，对象锁 当我们使用不同实例对象去调用方法的时候会发现结果并不是我们想象的20000，因为this
并发——synchronized 关键字
帆的博客
08-09 113
同步语句块的实现使用的是和指令，其中指令指向同步代码块的开始位置，指令则指明同步代码块的结束位置。修饰的方法并没有指令和指令，取得代之的确实是标识，该标识指明了该方法是一个同步方法。不过两者的本质都是对对象监视器 monitor 的获取。JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。
【Java并发编程 】同步——synchronized 关键字
weixin_44735928的博客
08-16 236
synchronized关键字
Java并发编程——synchronized关键字
ghw15221836342的博客
08-26 338
synchronized关键字概述一、线程安全问题二、如何解决线程安全问题三、synchronized 同步方法或者同步块1、synchronized方法2、synchronized 同步块3、class 对象锁四、可重入性五、注意事项1、内置锁与字符串常量2、锁的是对象而非引用六、总结 概述 在 Java 中，提供了两种方式来实现同步互斥访问：synchronized 和 Lock。本文针对 ...
java并发编程——synchronized关键字详解
mkfka的博客
07-28 200
synchronized概述 synchronized是java中的关键字，是一种对象锁（锁的是对象而非引用），作用粒度是对象。 synchronized的使用方法 synchronized通常有三种加锁方式： 同步代码块（锁的是括号中的对象） 通过一下几段代码来帮助理解一下： public class MyThread{ public void test() { synchronized (this) //锁的是当前对象 {
Java并发（二）——synchronized关键字和volatile关键字
JSai的博客
08-22 931
synchronized 关键字 synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。synchronized 关键字底层原理属于 JVM 层面。 使用： 修饰实例方法: 作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁 修饰静态方法：就是给当前类加锁，会作用于类的所有对象实例...
Java 并发 —— Synchronized 关键字和锁升级 【可下载 Synchronized_思维导图】
认知 行动 坚持
08-22 596
一、Synchronized使用场景 Synchronized 是一个 Java同步关键字，在某些多线程场景下，如果不进行同步会导致数据不安全，而 Synchronized 关键字就是用于代码同步。什么情况下会数据不安全呢，要满足两个条件：一是数据共享（临界资源），二是多线程同时访问并改变该数据。 下面是模拟火车票售卖的示例程序，具体如下： // Java 并发 —— Synchronized 关键字和锁升级 【争取小白也能看懂】 // 线程操作资源类 - 共享资源 class TrainTick.
java面试——深圳-乐信-Java高级.zip
09-26
- 线程同步机制：synchronized关键字，volatile关键字，Lock接口（如ReentrantLock）。 - 死锁、活锁、饥饿现象及避免策略。 - 线程通信：wait()、notify()、notifyAll()方法，生产者消费者模型。 - ...
java面试——上海-携程-Java高级.zip
09-26
- 线程同步：synchronized关键字、volatile变量、Lock接口（如ReentrantLock）以及Condition。 - 死锁、活锁和饥饿现象的识别与避免。 - 守护线程（Daemon Thread）的使用和理解。 4. **并发编程** - 并发工具...
java面试——深圳-蚂蚁金服-Java高级.zip
09-26
理解Thread、Runnable、Callable接口，以及如何实现线程同步（synchronized关键字、Lock接口）。面试中可能会涉及到线程状态转换，死锁的预防，以及如何设计高效的并发程序。 五、垃圾回收 理解Java内存模型，熟悉...
java学习----递归
qq_56798493的博客
07-13 148
【代码】java学习----递归。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
最新发布
m0_73456341的博客
07-14 743
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 855
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 977
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
Java 线程池详解
qq_41591215的博客
07-13 929
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
synchronized 关键字 锁 java
06-13
Java中的synchronized关键字也是一种锁，它可以用来保证多线程访问共享资源时的线程安全性。 synchronized关键字可以用来修饰方法或代码块，在修饰方法时相当于对整个方法进行加锁，在修饰代码块时则需要指定一个锁...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值