多线程访问 synchronized 方法的八种具体情况

最新推荐文章于 2023-07-20 12:11:11 发布
原创 最新推荐文章于 2023-07-20 12:11:11 发布 · 509 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨Java中线程同步的多种情形，包括不同线程访问同步与非同步方法的效果，静态同步方法的锁定机制，以及异常处理对锁的影响。通过具体示例代码，清晰展示各种场景下线程的执行顺序，帮助理解Java并发编程的核心概念。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

概述

  • 情况一：两个线程同时访问一个对象的 synchronized 方法，同步执行；
  • 情况二：两个线程访问的是两个对象的 synchronized 方法，并行执行；
  • 情况三：两个线程同时访问一个 synchronized 静态方法，同步执行；
  • 情况四：两个线程同时访问 synchronized 方法与非 synchronized 方法，并发执行；
  • 情况五：两个线程同时访问同一个对象的不同 synchronized 方法，同步执行；
  • 情况六：两个线程同时访问静态 synchronized 方法和非静态 synchronized 方法，并行执行；
  • 情况七：方法抛异常后，会释放锁；
  • 情况八：在 synchronized 方法中调用了普通方法，就不是线程安全的了，synchronized 的作用范围只在 “{}” 内；

示例四 - 同时访问同步方法与非同步方法

package com.example.concurrency.example.sync;

public class SynchronizedYesAndNo4 implements Runnable {

    static SynchronizedYesAndNo4 instance = new SynchronizedYesAndNo4();

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

    public synchronized void method1() {
        System.out.println(Thread.currentThread().getName() + " 访问 synchronized mothod1() 开始");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 访问 synchronized mothod1() 结束");
    }

    public void method2() {
        System.out.println(Thread.currentThread().getName() + " 访问 mothod2() 开始");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 访问 mothod2() 结束");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);

        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println(Thread.currentThread().getName() + " 结束");
    }

}

输出：

Thread-0 访问 synchronized mothod1() 开始
Thread-1 访问 mothod2() 开始
Thread-0 访问 synchronized mothod1() 结束
Thread-1 访问 mothod2() 结束
main 结束

示例五 - 两个线程同时访问同一个对象的不同 synchronized 方法

package com.example.concurrency.example.sync;

public class SynchronizedYesAndNo5 implements Runnable {

    static SynchronizedYesAndNo5 instance = new SynchronizedYesAndNo5();

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

    public synchronized void method1() {
        System.out.println(Thread.currentThread().getName() + " 访问 synchronized mothod1() 开始");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 访问 synchronized mothod1() 结束");
    }

    public synchronized void method2() {
        System.out.println(Thread.currentThread().getName() + " 访问 synchronized mothod2() 开始");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 访问 synchronized mothod2() 结束");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);

        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println(Thread.currentThread().getName() + " 结束");
    }

}

输出：

Thread-0 访问 synchronized mothod1() 开始
Thread-0 访问 synchronized mothod1() 结束
Thread-1 访问 synchronized mothod2() 开始
Thread-1 访问 synchronized mothod2() 结束
main 结束

示例六 - 两个线程同时访问静态 synchronized 方法和非静态 synchronized 方法

package com.example.concurrency.example.sync;

public class SynchronizedYesAndNo6 implements Runnable {

    static SynchronizedYesAndNo6 instance = new SynchronizedYesAndNo6();

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

    public synchronized static void method1() {
        System.out.println(Thread.currentThread().getName() + " 访问 synchronized static mothod1() 开始");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 访问 synchronized static mothod1() 结束");
    }

    public synchronized void method2() {
        System.out.println(Thread.currentThread().getName() + " 访问 synchronized mothod2() 开始");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 访问 synchronized mothod2() 结束");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);

        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println(Thread.currentThread().getName() + " 结束");
    }

}

输出：

Thread-1 访问 synchronized mothod2() 开始
Thread-0 访问 synchronized static mothod1() 开始
Thread-1 访问 synchronized mothod2() 结束
Thread-0 访问 synchronized static mothod1() 结束
main 结束

示例七 - 方法抛异常后，会释放锁

package com.example.concurrency.example.sync;

public class SynchronizedYesAndNo7 implements Runnable {

    static SynchronizedYesAndNo7 instance = new SynchronizedYesAndNo7();

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

    public synchronized void method1() {
        System.out.println(Thread.currentThread().getName() + " 访问 synchronized static mothod1() 开始");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        throw new RuntimeException();
    }

    public synchronized void method2() {
        System.out.println(Thread.currentThread().getName() + " 访问 synchronized mothod2() 开始");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 访问 synchronized mothod2() 结束");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);

        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println(Thread.currentThread().getName() + " 结束");
    }

}

输出：

Thread-0 访问 synchronized static mothod1() 开始
Exception in thread "Thread-0" java.lang.RuntimeException
Thread-1 访问 synchronized mothod2() 开始
    at com.example.concurrency.example.sync.SynchronizedYesAndNo7.method1(SynchronizedYesAndNo7.java:23)
    at com.example.concurrency.example.sync.SynchronizedYesAndNo7.run(SynchronizedYesAndNo7.java:10)
    at java.lang.Thread.run(Thread.java:745)
Thread-1 访问 synchronized mothod2() 结束
main 结束
【多线程】synchronized底层实现的方式
李光 未来科技
03-24 835
在java 开发中对于锁的应用非常的常见，如果对于什么时候该用什么锁，以及锁实现的原理有所不知道的，或者面试过程中面试官问你不知道怎么回答的，欢迎来看下面的文章。
深入Java多线程之synchronized方法锁：源码解析与实战应用
最新发布
m0_51176516的博客
06-07 1123
本文对Java多线程中的synchronized修饰方法进行了深入解析，包括其原理、源码以及实战应用。通过了解synchronized方法的底层实现机制和工作原理，可以更好地理解其在使用过程中的限制和性能影响，从而更加合理地使用它来确保多线程程序的正确性和性能。
Java多线程访问Synchronized同步方法的八种使用场景
五道口
05-22 2949
简介 本文将介绍8种同步方法的访问场景，我们来看看着八种情况下，多线程访问同步方法是否还是线程安全的。这些场景是多线程编程中经常遇到的，而且也是面试时高频被问到的问题，所以不管是理论还是实践，这些都是多线程场景必须要掌握的场景。 七种使用场景： 接下来，我们来通过代码实现，分别判断以下场景是不是线程安全的，以及原因是什么。 两个线程同时访问同一个对象的同步方法 两个线程同时访问两个对象的同步方法 两个线程同时访问（一个或两个）对象的静态同步方法 两个线程分别同时访问（一个或两个）对象的同步方法和非同步方法
多个线程访问不同的synchronized方法
lhxinbobo的博客
01-24 618
多个线程访问同一个synchronized方法，只有一个线程能够进入该方法。如果多个线程访问一个对象不同的synchronized方法呢？还是只有一个能进入吗？ 下面验证一下： package volatile1; import java.util.concurrent.CountDownLatch; /** * Created by sxb-gt on 2018/1/21. * “主
synchronized Lock（本地同步）锁的8种情况
Mr 敦（A.Dun）Java历险记
09-23 728
Lock（本地同步）锁的8种情况 总结与说明： * 题目： * 1.标准访问，请问是先打印邮件还是短信 Email * 2.email方法新增暂停4秒钟，请问是先打印邮件还是短信 Email * 3.新增普通的hello方法，请问先打印邮件还是hello hello * 4.两部手机，请问先打印邮件还是短信 SMS * 5.两个静态同步方法，1部手机，请问先打印邮件还是短信 Email * 6.两个静态同步方法，2部手机，请问先打印邮件还是短信 Email
synchronized的8种场景
老骆驼的博客
10-19 942
synchronized 对于Java中的同步方法，一直以来是一个比较难以理解的问题，这里根据自己学习过程中的记录整理了一份常见的线程操作情况。 线程操作资源类常见的8种情况: *1 标准访问，请问先打印邮件还是短信 *2 暂停4秒钟在邮件方法，请问先打印邮件还是短信 *3 新增普通sayHello方法，请问先打印邮件还是hello *4 两部手机，请问先打印邮件还是短信 *5 两个静态同步方法，同一部手机，请问先打印邮件还是短信 *6 两个静态同步方法，2部手机，请问先打印邮件还是短信 *7 1个静态同步
一个对象的多个synchronized方法多个线程调用
热门推荐
LMR的博客
05-29 1万+
今天遇到一个笔试题，说的是：当一个线程进入一个对象的synchronized方法之后，其它线程能否进入该对象的其他方法？ 答：很明显当其它方法是非synchronized方法时，调用是不受影响的，但当其它方法也是synchronized方法时呢？接下来我们进行实验验证： class Test{ public synchronized void synchronizedMethod...
java多线程编程之Synchronized块同步方法
09-03
在Java多线程编程中，`synchronized`关键字是一个至关重要的概念，用于实现线程间的同步，以确保共享资源的安全访问。本篇文章将深入探讨`synchronized`块同步方法及其应用，通过实例来阐述其工作原理。 首先，我们...
java 多线程的三种构建方法
08-29
总的来说，选择哪种多线程实现方式取决于具体的需求，如是否需要自定义线程类、是否需要与其他接口共存、是否需要更高级的线程管理等。在实际开发中，往往结合使用这些方法，以实现最优的并发性能和资源利用。
Java多线程synchronized关键字详解(六)共5
10-30
在Java编程语言中，`synchronized`关键字是用于实现线程同步的重要机制，它确保了在多线程环境中的数据一致性与安全性。本篇将详细解析`synchronized`的关键特性和使用方法，帮助开发者深入理解如何在并发编程中有效...
JUC-----------（三）详解synchronized八种情况
weixin_43664907的博客
04-10 206
8锁现象 1、标准访问，请问先打印邮件还是短信 public class A { public static void main(String[] args) { Phone phone = new Phone(); new Thread(() -> { phone.sendEmail(); }, "A").start(); new Thread(() -> { phone.s
八种情况下分析Sychronized锁的执行
我能在河边钓一整天的鱼
05-31 271
目录 情况1+2、两个方法锁一个对象(有无sleep) 情况3、一个对象，二个方法(一个带锁的方法，一个普通方法) 情况4、两个对象，两个同步方法 情况5+6、两个静态同步方法(一个对象/两个对象) 情况7+8、一个静态同步方法一个同步方法(一或二个对象) 总结 情况1+2、两个方法锁一个对象(有无sleep) 只要这个对象被一个方法锁住了，其他方法就不能执行，必须等这个对象释放后，才能执行。 所以两个方法锁一个对象，不论是否其中的一个方法有sleep，永远是先拿到锁的方法先执行 .
多线程同步synchronized使用
wq892373445的博客
04-05 425
当使用多线程访问同一个资源的时候，非常容易出现线程安全的问题（例如，当多个线程同时对一个数据进行修改的时候，会导致某些线程对数据的修改丢失）。 线程安全概念：当多个线程访问某一个类（对象或方法）时，这个对象始终都能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。 因此，需要采用同步机制来解决这种问题。而Java主要提供了三种实现同步机制的方法。 一、synchronized(同步代码块)...
多线程中Synchronized的用法
欧阳北鼻的博客
03-20 646
Java中Synchronized的用法 在java中synchronized关键字是用来控制线程同步的，在多线程的环境下，被synchronized关键字修饰的代码块可以不被多个同时执行。 总结： A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有...
多个线程访问多个对象的synchronized方法
zhengqianjin的博客
07-19 662
当多个线程访问不同的对象的synchronized 方法时，会是什么样呢？ 先看代码 如下： public class MyThread2 { private int num =0; public synchronized void run(String flag){ try { if("a".equals(flag)){ num =10; System.out.println("flag a , set num over"); Thread.sleep(100
Java多线程(一) synchronized同步方法
Java Spring Elasticsearch
11-01 414
synchronized同步方法1.提出问题-实例变量非线程安全1.1 何为非线程安全？1.2 举例1.2.1 有私有变量的类HasPrivateNum (供多线程们去调用)1.2.2 线程A1.2.3 线程B1.2.4 开启AB线程共同访问1个对象1.2.5 执行结果(多次执行有几率出现如下结果)2. 解决问题-给方法上加synchronized2.1 synchronized修饰范围2.2 修...
Java多线程之synchronized
qq_35716085的博客
07-20 6455
synchronized具有同步功能，是一种互斥锁，锁的是对象。如果既想保证共享变量的可见性和有序性，又想保证原子性，那么synchronized关键字是一个不错的选择。synchronized的缺点：1.synchronized底层是由jvm实现，因此不能手动控制锁的释放，不如lock锁灵活，synchronized修饰的方法一旦出现异常，jvm保证锁会被释放（lock锁需要在finally中释放）。2.synchronized是非公平锁，不保证公平性。
JAVA并发与多线程-线程同步 synchronized 修饰方法
xiaoleilei666的博客
01-31 393
在JAVA多线程编程中，将需要并发执行的代码放在Thread类的run方法里面，然后创建多个Thread类的对象，调用start()方法，线程启动执行。 当某段代码需要互斥时，可以用 synchronized 关键字修饰，这里讨论 synchronized 关键字修饰方法时，是如何互斥的。 synchronized 修饰方法时锁定的是调用该方法的对象。它并不能使调用该方法的多个对象在执行顺序上互斥...
static synchronized 方法的多线程访问和作用
suncat的博客
07-29 1405
synchronized与static synchronized 的区别： synchronized是对类的当前实例进行加锁，防止其他线程同时访问该类的该实例的所有synchronized块，注意这里是“类的当前实例”，类的两个不同实例就没有这种约束了。 那么static synchronized恰好就是要控制类的所有实例的访问了，static synchronized是限制线程同时访问jvm...
Java多线程编程synchronized用法实例解析
在Java编程中，synchronized关键字是一个非常重要的同步控制机制，用于控制多线程对共享资源的访问。它是实现线程安全的重要手段之一，可以用于方法、语句块中，涉及到类锁和对象锁的概念。本文将详细介绍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值