synchronized的8大应用场景分析

最新推荐文章于 2024-03-06 20:04:14 发布
最新推荐文章于 2024-03-06 20:04:14 发布
阅读量2k 收藏 6
点赞数 4
分类专栏： java知识 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36174081/article/details/111400836
版权

synchronized的8大应用场景分析

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

　  1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； ---对象锁

　　2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； --对象锁

　　3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； ---类锁

　　4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。--类锁

场景一：两个线程同时访问同一个对象的同步方法。

这是经典的对象锁中的方法锁，两个线程争夺同一个对象锁，但是两个线程是属于同一对象的，所以会互相等待，是线程安全的。

package com.demo.thread;

public class SynchronizedTest implements Runnable{
   
    static SynchronizedTest instance1 = new SynchronizedTest();

    @Override
    public void run() {
        method();
    }

    // 用synchronized对method方法机进行同步
    private  synchronized void method(){
        System.out.println("线程名" + Thread.currentThread().getName()+",开始运行");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程" + Thread.currentThread().getName() + ",运行结束");
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(instance1);
        Thread thread2 = new Thread(instance1);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){
        }
        System.out.println("测试结束");
    }
}

运行结果：
线程名Thread-0,开始运行
线程Thread-0,运行结束
线程名Thread-1,开始运行
线程Thread-1,运行结束
测试结束

场景二：两个线程同时访问两个对象的锁。

这个就是对象锁失效的场景，原因在访问的是两个对象的同步方法，那么这两个线程分别持有的是两个线程的锁，因此两线程之间是相互不影响的。这时加锁启不到任何作用。我们加锁的目的就是为了让多个线程竞争同一把锁。因此这种场景下是线程不安全的。

package com.demo.thread;

public class SynchronizedTest implements Runnable{
    //创建两个不同的对象
    static SynchronizedTest instance1 = new SynchronizedTest();
    static SynchronizedTest instance2 = new SynchronizedTest();
    
    @Override
    public void run() {
        method();
    }

    // 用synchronized对method方法机进行同步
    private synchronized void method(){
        System.out.println("线程名" + Thread.currentThread().getName()+",开始运行");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程" + Thread.currentThread().getName() + ",运行结束");
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(instance1);
        Thread thread2 = new Thread(instance2);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){
        }
        System.out.println("测试结束");
    }
}
运行结果：
线程名Thread-0,开始运行
线程名Thread-1,开始运行
线程Thread-0,运行结束
线程Thread-1,运行结束
测试结束

场景三：两个线程同时访问(一个或两个)对象的静态同步方法

这个场景即是场景二中的线程安全的解决方法，在方法上添加了static方法，作用对象是这个类的所有对象，所以是线程安全的。

package com.demo.thread;

/**
 * @Author Zhangnana
 * @DATE 2020/12/19 9:39
 * @Version 1.0
 */
public class SynchronizedTest implements Runnable{
    //创建两个不同的对象
    static SynchronizedTest instance1 = new SynchronizedTest();
    static SynchronizedTest instance2 = new SynchronizedTest();

    @Override
    public void run() {
        method();
    }

    // 用synchronized对method方法机进行同步
    private synchronized static void method(){
        System.out.println("线程名" + Thread.currentThread().getName()+",开始运行");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程" + Thread.currentThread().getName() + ",运行结束");
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(instance1);
        Thread thread2 = new Thread(instance2);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){
        }
        System.out.println("测试结束");
    }
}
结果：
 	线程名Thread-0,开始运行
	线程Thread-0,运行结束
	线程名Thread-1,开始运行
	线程Thread-1,运行结束
	测试结束

场景四：两个线程分别同时访问一个或两个对象的同步方法和非同步方法

这个场景是指两个线程其中一个访问的是同步方法，另一个访问的是非同步方法，此时，线程是否安全呢？

我们可以很确定的说是线程不安全的。从结果可以看出是线程不安全的。

package com.demo.thread;

/**
 * @Author Zhangnana
 * @DATE 2020/12/19 9:39
 * @Version 1.0
 */
public class SynchronizedTest implements Runnable{
    //创建两个不同的对象
    static SynchronizedTest instance1 = new SynchronizedTest();
    static SynchronizedTest instance2 = new SynchronizedTest();

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")){
            method0();
        }
        if (Thread.currentThread().getName().equals("Thread-1")){
            method1();
        }
    }

    // 同步方法
    private synchronized static void method0(){
        System.out.println("线程名" + Thread.currentThread().getName()+",开始运行");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程" + Thread.currentThread().getName() + ",运行结束");
    }

    //普通方法
    public void method1(){
        System.out.println("线程名" + Thread.currentThread().getName()+",开始运行");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程" + Thread.currentThread().getName() + ",运行结束");
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(instance1);
        Thread thread2 = new Thread(instance2);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){
        }
        System.out.println("测试结束");
    }
}

结果
	线程名Thread-0,开始运行
	线程名Thread-1,开始运行
	线程Thread-1,运行结束
	线程Thread-0,运行结束
	测试结束

场景五：两个对象访问同一个对象中的同步方法，且同步方法中调用非同步方法

这个场景是用两个线程去调用同步方法，同步方法中去调用非同步方法，在用一个线程直接去调用普通方法。从结果中可以看出，thread0和thread2的普通方法是并行运行的，此时是线程不安全的。若想做到线程安全，必须确保在同步方法中调用非同步方法时，没有别的线程对其进行操作。

package com.demo.thread;

/**
 * @Author Zhangnana
 * @DATE 2020/12/19 9:39
 * @Version 1.0
 */
public class SynchronizedTest implements Runnable{
    //创建两个不同的对象
    static SynchronizedTest instance1 = new SynchronizedTest();
    static SynchronizedTest instance2 = new SynchronizedTest();

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }else {
            method0();
        }

    }

    // 同步方法
    private synchronized  void method0(){
        System.out.println("线程名" + Thread.currentThread().getName()+"同步方法,开始运行");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程" + Thread.currentThread().getName() + "同步方法,运行结束。开始调用普通方法");
        method1();
    }

    //普通方法
    public void method1(){
        System.out.println("线程名" + Thread.currentThread().getName()+"普通方法,开始运行");
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程" + Thread.currentThread().getName() + "普通方法,运行结束");
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(instance1);
        Thread thread2 = new Thread(instance1);
        Thread thread3 = new Thread(instance1);
        thread1.start();
        thread2.start();
        thread3.start();
        while (thread1.isAlive() || thread2.isAlive() || thread3.isAlive()){
        }
        System.out.println("测试结束");
    }
}

线程名Thread-2同步方法,开始运行
线程名Thread-0普通方法,开始运行
线程Thread-2同步方法,运行结束。开始调用普通方法
线程名Thread-2普通方法,开始运行
线程Thread-0普通方法,运行结束
线程Thread-2普通方法,运行结束
线程名Thread-1同步方法,开始运行
线程Thread-1同步方法,运行结束。开始调用普通方法
线程名Thread-1普通方法,开始运行
线程Thread-1普通方法,运行结束
测试结束

场景六：两个线程同时访问同一个对象的不同的同步方法

此时获得的是对象锁，同一对象中，访问不同的同步方法是线程安全的。若是访问的是不同对象中的不同的同步方法时线程不安全的。根据synchronized修饰的具体内容，判断获取的是哪种锁。

package com.demo.thread;

/**
 * @Author Zhangnana
 * @DATE 2020/12/19 9:39
 * @Version 1.0
 */
public class SynchronizedTest implements Runnable{
    //创建两个不同的对象
    static SynchronizedTest instance1 = new SynchronizedTest();
    static SynchronizedTest instance2 = new SynchronizedTest();

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }
        if (Thread.currentThread().getName().equals("Thread-1")){
            method0();
        }

    }

    // 同步方法
    private synchronized  void method0(){
        System.out.println("线程名" + Thread.currentThread().getName()+"同步方法,开始运行");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程" + Thread.currentThread().getName() + "同步方法,运行结束。开始调用普通方法");
        method1();
    }

    //普通方法
    public synchronized void method1(){
        System.out.println("线程名" + Thread.currentThread().getName()+"普通方法,开始运行");
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程" + Thread.currentThread().getName() + "普通方法,运行结束");
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(instance1);
        Thread thread2 = new Thread(instance1);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){
        }
        System.out.println("测试结束");
    }
}

线程名Thread-0普通方法,开始运行
线程Thread-0普通方法,运行结束
线程名Thread-1同步方法,开始运行
线程Thread-1同步方法,运行结束。开始调用普通方法
线程名Thread-1普通方法,开始运行
线程Thread-1普通方法,运行结束
测试结束

场景七：两个线程分别同时访问静态synchronized和非静态synchronized

方法

这个场景的本质是两个线程获取的是不是同一把锁的问题，我们知道静态synchronized方法获取的类锁，非静态获取得是对象锁，两个线程拿到的锁是不同的锁，所有不会互相等待，是线程不安全的。

package com.demo.thread;

/**
 * @Author Zhangnana
 * @DATE 2020/12/19 9:39
 * @Version 1.0
 */
public class SynchronizedTest implements Runnable{
    //创建两个不同的对象
    static SynchronizedTest instance1 = new SynchronizedTest();
    static SynchronizedTest instance2 = new SynchronizedTest();

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }
        if (Thread.currentThread().getName().equals("Thread-1")){
            method0();
        }

    }

    // 同步方法
    private synchronized static void method0(){
        System.out.println("线程名" + Thread.currentThread().getName()+",开始运行");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程" + Thread.currentThread().getName() + "运行结束。");
    }

    //普通方法
    public synchronized void method1(){
        System.out.println("线程名" + Thread.currentThread().getName()+",开始运行");
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程" + Thread.currentThread().getName() + ",运行结束");
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(instance1);
        Thread thread2 = new Thread(instance2);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){
        }
        System.out.println("测试结束");
    }
}

线程名Thread-0,开始运行
线程名Thread-1,开始运行
线程Thread-1运行结束。
线程Thread-0,运行结束
测试结束

场景八：同步方法抛出异常后，JVM会自定释放锁的情况

只有当同步方法执行完成或执行时抛出异常这两种情况，才会释放锁。

码代码的小仙女
关注
专栏目录
Java并发编程(四)—synchronized关键字的应用
echola_mendes的博客
08-05 1531
synchronized 关键字是 Java 中用来确保线程安全的基本机制，特别是在需要保证多个变量之间的一致性时。通过使用 synchronized，可以锁定一个对象，从而确保同一时刻只有一个线程可以访问该对象可以将 synchronized 用于方法级别和代码块级别，要注意锁定的对象应该是一个合适的对象，不能是一个常量，使用 synchronized 可以简化并发控制逻辑，但需要注意其性能开销和潜在的死锁风险。
java de 线程池
tayloramanda的博客
09-16 744
线程池： java.util.concurrent.Executors提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池 作用：解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。 使用情况： 假设一个服务器完成一项任务所需时间为： T1 创建线程时间， T2 在线程中执行任务的时间， T3 销毁线程时间。 如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。 组成部分： ...
JMeter之Ramp-up Period（in seconds）说明（可同时并发）
热门推荐
Seleton的专栏
02-25 6万+
Ramp-up Period（in seconds） 【1】决定多长时间启动所有线程。如果使用10个线程，ramp-up period是100秒，那么JMeter用100秒使所有10个线程启动并运行。每个线程会在上一个线程启动后10秒（100/10）启动。Ramp-up需要要充足长以避免在启动测试时有一个太大的工作负载，并且要充足小以至于最后一个线程在第一个完成前启动。  一般设置ram
Java面试题总结（乱序版，2020-09-29）
学Java，找哪吒
10-11 4097
一、哪些集合类是线程安全的？ 二、Java 中的线程池是如何实现的 三、创建线程池的几个核心构造参数？ 四、线程池中的线程是怎么创建的？是一开始就随着线程池的启动创建好的吗？ 五、spring mvc 和 struts 的区别是什么？ 六、get 和 post 请求有哪些区别？ 七、设计一个 ATM 机，请说出你的设计思路？ 八、请举例解释@Required 注解？ 九、请举例解释@Autowired 注解？ 十、请举例说明@Qualifier 注解？ 十一、如何使用 Spring Bo
Java多线程访问Synchronized同步方法的八种使用场景
五道口
05-22 2588
简介 本文将介绍8种同步方法的访问场景，我们来看看着八种情况下，多线程访问同步方法是否还是线程安全的。这些场景是多线程编程中经常遇到的，而且也是面试时高频被问到的问题，所以不管是理论还是实践，这些都是多线程场景必须要掌握的场景。 七种使用场景： 接下来，我们来通过代码实现，分别判断以下场景是不是线程安全的，以及原因是什么。 两个线程同时访问同一个对象的同步方法 两个线程同时访问两个对象的同步方法 两个线程同时访问（一个或两个）对象的静态同步方法 两个线程分别同时访问（一个或两个）对象的同步方法和非同步方法
一口气说出 Synchronized 同步方法的八种使用场景
Java笔记虾
10-17 1135
简介 本文将介绍7种同步方法的访问场景，我们来看看着七种情况下，多线程访问同步方法是否还是线程安全的。这些场景是多线程编程中经常遇到的，而且也是面试时高频被问到的问题，所以不管是理论还是...
synchronized ReentrantLock volatile Atomic 原理分析.docx
06-26
本文将深入探讨四种关键的并发控制机制：synchronized关键字、ReentrantLock（可重入锁）、volatile关键字以及Atomic类的原理与应用。 ### 1. synchronized关键字 `synchronized`关键字是Java提供的内置锁，用于...
Synchronized关键字对比volatile关键字的应用场景和区别
本文旨在对比Synchronized关键字和volatile关键字的应用场景和区别，帮助读者更好地理解和使用这两个关键字。 ## 1.2 概述Synchronized关键字和volatile关键字的基本作用 - Synchronized关键字用于对方法或代码块...
Java线程Dump分析工具jstack解析及使用场景
10-18
本文将深入解析jstack的使用方法及其在不同场景下的应用。 jstack命令的基本格式如下： ``` jstack [-l] [-F] pid ``` 其中，`pid` 是Java进程的ID，`-l` 选项会提供更详细的线程和锁信息，而 `-F` 选项则用于在...
浙江大学Java应用技术资料.7z
12-09
4. **集合框架**：Java集合框架包括List、Set、Queue、Map等接口和它们的实现类，如ArrayList、LinkedList、HashSet、HashMap等，学习它们的特性及应用场景。 5. **IO流与NIO**：学习输入输出流的使用，包括字符流...
ThreadLocal 深入源码分析&应用场景介绍
架构探险之道
05-28 378
在 Java 的多线程编程中，为保证多个线程对共享变量的安全访问，通常会使用 synchronized 或是 Lock 工具类等方式来保证同一时刻只有一个线程对共享变量进行操作。这种情况下可以将类变量放到ThreadLocal类型的对象中，使变量在每个线程中都有独立拷贝，不会出现一个线程读取变量时而被另一个线程修改的现象。 最常见的ThreadLocal使用场景为用来解决数据库连接、Session管理、用户信息线程上下文管理等。
Ramp-up Period（in seconds）
MENG_Q_Z的博客
07-17 685
因为假如设置成零，Jmeter将会在测试的开始就建立全部线程并立即发送访问请求，这样一来就很轻易使服务器饱和，更重要的是会隐性地增加了负载，这就意味着服务器将可能过载，不是因为平均访问率高而是因为所有线程的第一次并发访问而引起的不正常的初始访问峰值。Ramp-up需要足够长以避免在启动测试时有一个太大的工作负载，并且要足够小以至于最后一个线程在第一个完成前启动。基于同样的原因，过大的ramp-upperiod也是不恰当的，因为将会降低访问峰值，在一些线程还未启动时，初期启动的部分线程就结束了。......
并发编程的艺术（2）：Synchronized的使用场景
m0_50275872的博客
04-20 844
Synchronized
synchronized 使用场景
dzh145的专栏
04-25 420
package test; public class ThreadJoinTest { private static class Count extends Thread{ private ThreadJoinTest simplOper; Object obj = new Object(); publ...
Jmeter之Ramp-up Period（in seconds）
最新发布
晴天的博客
03-06 1095
Jmeter之Ramp-up Period（in seconds）
在使用 Response.End、Response.Redirect 或 Server.Transfer 时出现 ThreadAbortException
TonyChi 's Tech Space
02-26 2298
PRB：在使用 Response.End、Response.Redirect 或 Server.Transfer 时出现 ThreadAbortException最后修改 : 2005年10月24日 症状如果使用 Response.End、Response.Redirect 或 Server.Transfer 方法，将出现 ThreadAbortException 异常。您可以使用
synchronized的各种场景用法详解
weixin_44947701的博客
05-15 2729
概述 synchronized是java的关键字，它的作用是加同步锁，即被synchronized修饰的部分同一时间只允许一个线程访问，它的使用场景有如下几种： 修饰普通方法：对当前对象实例加锁，调用该方法需要获得当前对象实例的锁 修饰静态方法：对当前类加锁，会对该类的所有实例加锁，因为静态方法不属于任何一个实例对 象，是属于类成员。所以当线程A访问调用一个实例对象的synchronized方法，线程B调用这个实例对象的静态synchronized方法是允许的 修饰代码块：对指定的对象加锁，可以指定变
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值