Synchronized使用情况分析

最新推荐文章于 2024-08-04 11:07:52 发布
最新推荐文章于 2024-08-04 11:07:52 发布
阅读量488 收藏 6
点赞数 11
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_FateTao/article/details/137233221
版权
七种情况分析
1、方法都使用synchronized进行修饰，一个 phone 实例
import java.util.concurrent.TimeUnit;

public class SpringBootTestApplicationDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() ->{
            phone.sendMessage();
        }, "threadA").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() ->{
            phone.callUp();
        }, "threadB").start();
    }
}

class Phone{

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

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

执行结果：

发短信
打电话

结果分析

为什么先是发短信后是打电话？

原因：synchronized 修饰，锁的是当前调用对象，由于 phone 实例对象只有一个，所以哪个线程先拿到锁，哪个线程先执行

2、方法都使用synchronized进行修饰，两个 phone 实例
import java.util.concurrent.TimeUnit;

public class SpringBootTestApplicationDemo {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

        new Thread(() ->{
            phone1.sendMessage();
        }, "threadA").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() ->{
            phone2.callUp();
        }, "threadB").start();
    }
}

class Phone{

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

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

执行结果：

打电话
发短信

结果分析

为什么先是发打电话后是发短信？

原因：synchronized 修饰，锁的是当前调用对象，由于 phone 实例对象有两个，不存在竞争锁

3、增加了一个普通方法，没有使用 synchronized 修饰
import java.util.concurrent.TimeUnit;

public class SpringBootTestApplicationDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() ->{
            phone.sendMessage();
        }, "threadA").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() ->{
            phone.say();
        }, "threadB").start();
    }
}

class Phone{

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

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

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

执行结果：

hello word
发短信

结果分析

为什么先是hello word后是发短信？

原因：synchronized 修饰，锁的是当前调用对象，phone 实例对象虽只有一个，但是普通方法的调用，不需要锁

4、两个静态的同步方法，一个对象调用
import java.util.concurrent.TimeUnit;

public class SpringBootTestApplicationDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() ->{
            phone.sendMessage();
        }, "threadA").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() ->{
            phone.callUp();
        }, "threadB").start();
    }
}

class Phone{

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

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

执行结果：

发短信
打电话

结果分析

为什么先是发短信后是打电话？

原因：static 和 synchronized 修饰，锁的是当前类 class 实例，由于 class 实例是在类加载时创建（Phone.class），只有一个，所以谁先拿到锁，谁先执行（这里和Phone实例对象无关）

可以换种方式理解，主要是 静态属性 or 方法 随着类加载，在内存中只有一份

Class<?> phone1 = Class.forName("Phone");
Class<Phone> phoneClass = Phone.class;
System.out.println(phone1 == phoneClass);

/**
 * 执行结果 true
 * class 实例验证
 */
5、两个静态的同步方法，两个对象调用
import java.util.concurrent.TimeUnit;

public class SpringBootTestApplicationDemo {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();


        new Thread(() ->{
            phone1.sendMessage();
        }, "threadA").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() ->{
            phone2.callUp();
        }, "threadB").start();
    }
}

class Phone{

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

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

执行结果：

发短信
打电话

结果分析

为什么先是发短信后是打电话？

原因：static 和 synchronized 修饰，锁的是当前类 class 实例，由于 class 实例是在类加载时创建（Phone.class），只有一个，所以谁先拿到锁，谁先执行，这里和多个 Phone 实例无关

6、静态同步方法和普通同步方法，一个对象调用
import java.util.concurrent.TimeUnit;

public class SpringBootTestApplicationDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() ->{
            phone.sendMessage();
        }, "threadA").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() ->{
            phone.callUp();
        }, "threadB").start();
    }
}

class Phone{

    //静态同步方法
    public static synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

执行结果：

打电话
发短信

结果分析

为什么先是发打电话后是发短信？

原因：普通同步方法 和 静态同步方法锁的对象不同，一个是当前调用者实例，一个是 class实例，它们之间没有关系，不影响相互执行

7、 静态同步方法和普通同步方法，两个对象调用
import java.util.concurrent.TimeUnit;

public class SpringBootTestApplicationDemo {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();


        new Thread(() ->{
            phone1.sendMessage();
        }, "threadA").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() ->{
            phone2.callUp();
        }, "threadB").start();
    }
}

class Phone{

    //静态同步方法
    public static synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

执行结果：

打电话
发短信

Mr_FateTao
关注
  • 11
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
synchronized锁原理分析（二、锁的膨胀过程）
12-21
本文将深入分析`synchronized`锁的膨胀过程，这个过程涉及到锁从无锁状态到轻量级锁，再到重量级锁的升级。 首先，我们需要理解Java对象头中的Mark Word，它是一个重要的数据结构，用于存储对象的锁状态和其他信息...
synchronized并发讲解源码.zip
03-16
本文将深入解析`synchronized`的工作原理、使用方式以及它在并发编程中的重要性。通过分析提供的源码，我们可以更直观地理解这个关键字的实际应用。 `synchronized`关键字主要有两种用法：修饰实例方法和同步代码块...
synchronized使用的正确姿势
蜕变的快乐
07-28 1626
synchronized关键字在java中是用作线程同步的，保障同步区代码的正确执行，同一时间仅有一个线程进入同步区，其原理是使用锁技术，通过竞争，得到锁的线程执行同步区代码，未得到锁的线程自旋、阻塞等待。下面分为四个部分来对synchronized进行分析： 三种使用方式 实例讲解 单例中的使用 原理浅析 请您站稳扶好，开车了… 三种使用方式 分别是修饰实例方法，修饰静态方法，修饰代码块...
Synchronized关键字的深入分析
在途中
04-26 1523
synchronized从入门到精通
synchronized锁简单分析
maomao的博客
07-28 1329
有关锁升级的一些面试话术整理
【事务与锁】当Transactional遇上synchronized
qq_43843951的博客
03-15 22万+
最近工作中遇到某些七七八八的问题，就是与事务和锁、并发都有着紧密联系相关的问题所在。主要情况是：通过调用方法获取编号，而这个编号是递增有序的，并且存在于数据库中，简单理解就是需要用到这种编号(以下称任务编号)，需要从数据库获取出来，在+1最为本次需要的编号，然后在存回数据库中，提供下次使用。直观来看是没得问题的，但是，可能在某次并发的时候出现编号相同，着属实很令人头疼，在经过领导的指导下是完美的解决了，接下来复盘一下。
php synchronized,synchronized关键字使用详解
weixin_34665627的博客
04-01 484
简述计算机单线程在执行任务时，是严格按照程序的代码逻辑，按照顺序执行的。因此单位时间内能执行的任务数量有限。为了能在相同的时间内能执行更多的任务，就必须采用多线程的方式来执行(注意：多线程模式无法减少单次任务的执行时间)。但是引入了多线程之后，又带来了线程安全的问题。而为了解决线程安全的问题，又引入了锁的概念。java中常用的锁有synchronized和lock两种，本文我们来分析synchro...
synchronized底层原理分析
做Java整整10年，目前是教别人写代码，嘿嘿
10-29 1388
如果某一个资源被多个线程共享，为了避免因为资源抢占导致资源数据错乱，我们需要对线程进行同步，那么synchronized就是实现线程同步的关键字，可以说在并发控制中是必不可少的部分，今天就来看一下synchronized的使用和底层原理。 一、synchronized的特性 1.1 原子性 所谓原子性就是指一个操作或者多个操作，要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。 在Java中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不..
深入分析 Synchronized 原理
养歌的博客
02-07 2078
Synchronized 简介 Synchronized 是 Java 中的关键字，是一种同步锁。在多线程编程中，有可能会出现多个线程同时争抢同一个共享资源的情况，这个资源一般被称为临界资源。这种共享资源可以被多个线程同时访问，且又可以同时被多个线程修改，然而线程的执行是需要 CPU 的资源调度，其过程是不可控的，所以需要采用一种同步机制来控制对共享资源的访问，于是线程同步锁—— Synchronized 就应运而生了。 Synchronized 用法 Synchronized 关键字主要有以下 3 种使用
synchronized实现和原理分析
阿飞云漫步
03-29 1225
大家好，我是阿飞云怕什么真理无穷，进一步有近一步的欢喜本文大致梳理相关的内容：synchronized的使用方式？synchronized 加载静态方法和加载普通方法上面有什么区别？synchronized 在jdk1.6 加锁流程是怎样的？知道Java对象头吗？在synchronized有什么用？synchronized初识synchronized是Java多线程中元老...
synchronized 使用及深入理解
weixin_42118323的博客
04-01 728
两个线程同时做 1000 次循环，结果 2000，线程安全没有问题，根据打印结果我们可以知道，两个线程本质是顺序执行的，也就是一个线程获取到锁后，直到他执行完了另外一个线程才可以获取到锁继续执行，两个不同的线程也就是两个不同的实例，这也证明了锁住的是实例对象。两个线程同时做 1000 次循环，结果 2000，线程安全没有问题，注意如果我们开启注释的那行代码，将会线程不安全，因为两个线程用的锁不是同一个，做不到互斥性，所以线程不安全，有兴趣的朋友可以去试一下，这也证明了修饰代码块时候，锁对象是指定的对象。
深入理解Java并发之synchronized实现原理
热门推荐
zejian的博客
06-04 40万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/72828483 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深...
透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别
08-27
在实际开发中，我们可以使用 Synchronized 来锁定某个对象的实例，而使用 Static Synchronized 来锁定该类的所有实例。这样可以更好地控制多线程的并发访问。 实例分析 在上面的代码示例中，我们可以看到，...
java synchronized demo
04-19
在Java编程语言中，`...总结，`java synchronized demo`是一个关于如何在Java中使用`synchronized`关键字进行线程同步的示例，通过理解和实践这个例子，开发者可以更好地掌握多线程环境下数据安全和同步的重要性。
jvm细节探索之synchronized及实现问题分析
08-28
3. 轻量级锁（Lightweight Locking）：在无锁竞争的情况下，使用CAS操作代替MutexLock，降低开销。当有锁竞争时，会升级为重量级锁。 4. 偏向锁（Biased Locking）：在无锁竞争时，减少CAS操作，提高单线程场景下的...
枚举工具类
qq_43049583的博客
08-04 217
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 209
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 614
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 563
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
写一篇关于synchronized的文章
03-25
另外，在多线程访问的环境下，可能会出现死锁的情况，这时候需要及时分析并解决。 总之，Synchronized是Java中非常重要和常用的一个关键字，它能够保证多个线程之间的同步，避免了数据竞争和不可预测的结果。在实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值