多线程访问同步方法的7种情况（面试常考）

最新推荐文章于 2023-10-09 23:22:11 发布
最新推荐文章于 2023-10-09 23:22:11 发布
阅读量743 收藏 3
点赞数 1
分类专栏： Java多线程 文章标签： Java线程同步 Synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/b15735105314/article/details/100558783
版权

1、两个线程同时访问一个对象的同步方法

public class SynchronizedObjectMethod implements Runnable {
    private static SynchronizedObjectMethod synchronizedObjectMethod = new
            SynchronizedObjectMethod();

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

    public synchronized void test(){
        System.out.println("test()方法运行开始" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test()方法运行结束" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(synchronizedObjectMethod);
        Thread t2 = new Thread(synchronizedObjectMethod);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");
    }
}

代码运行结果：
test()方法运行开始Thread-0
test()方法运行结束Thread-0
test()方法运行开始Thread-1
test()方法运行结束Thread-1
程序运行结束

2、两个线程访问的是两个对象的同步方法

public class SynchronizedObjectMethod implements Runnable {
    private static SynchronizedObjectMethod instance1 = new
            SynchronizedObjectMethod();
    private static SynchronizedObjectMethod instance2 = new
            SynchronizedObjectMethod();

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

    public synchronized void test(){
        System.out.println("test()方法运行开始" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test()方法运行结束" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");
    }
}


代码运行结果：
test()方法运行开始Thread-0
test()方法运行开始Thread-1
test()方法运行结束Thread-0
test()方法运行结束Thread-1
程序运行结束

如果两个线程访问的是两个对象的同步方法，那么这两个线程的运行时互不影响的。

3、两个线程访问的是synchronized的静态方法

public class SynchronizedClassStatic implements Runnable {
    private static SynchronizedClassStatic instance1 = new SynchronizedClassStatic();
    private static SynchronizedClassStatic instance2 = new SynchronizedClassStatic();

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

    public synchronized static void test(){
        System.out.println("test()方法运行开始\t" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test()方法运行结束\t" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");

    }
}


代码运行结果：
test()方法运行开始	Thread-0
test()方法运行结束	Thread-0
test()方法运行开始	Thread-1
test()方法运行结束	Thread-1
程序运行结束

4、同时访问同步方法与非同步方法

synchronized关键字只作用于被修饰的方法或代码块上，不会影响到其他没有被synchronized修饰的方法或代码。

public class SynchronizedYesAndNo implements Runnable {
    private static SynchronizedYesAndNo instance = new SynchronizedYesAndNo();
    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            test0();
        } else {
            test1();
        }
    }

    public synchronized void test0(){
        System.out.println("synchronized test0()方法运行开始\t" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("synchronized test0()方法运行结束\t" + Thread.currentThread().getName());
    }

    public void test1(){
        System.out.println("test1()方法运行开始\t" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test1()方法运行结束\t" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");
    }
}

代码运行结果：
synchronized test0()方法运行开始	Thread-0
test1()方法运行开始	Thread-1
synchronized test0()方法运行结束	Thread-0
test1()方法运行结束	Thread-1
程序运行结束

5、访问同一个对象的不同的普通同步方法

就同一个实例而言，多线程在访问该实例的不同的普通同步方法的时候，多线程之间会顺序执行，而不会同时执行，因为synchronized虽然修饰的方法不同，但是他们的锁对象（this）确是同一个，而一个锁在同一时刻只能被一个线程占用。

public class SynchronizedDiffMethod implements Runnable {
    private static SynchronizedDiffMethod instance = new SynchronizedDiffMethod();
    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            test0();
        } else {
            test1();
        }
    }

    public synchronized void test0(){
        System.out.println("synchronized test0()方法运行开始\t" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("synchronized test0()方法运行结束\t" + Thread.currentThread().getName());
    }

    public synchronized void test1(){
        System.out.println("synchronized test1()方法运行开始\t" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("synchronized test1()方法运行结束\t" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");
    }
}

代码运行结果：
synchronized test0()方法运行开始	Thread-0
synchronized test0()方法运行结束	Thread-0
synchronized test1()方法运行开始	Thread-1
synchronized test1()方法运行结束	Thread-1
程序运行结束

6、同时访问静态synchronized和非静态synchronized方法

两个线程同时访问一个实例的静态synchronized和非静态synchronized方法的时候，两个线程是同时执行的，互不干扰的，原因就在于锁对象不是同一个，一个锁是当前实例对象，一个锁是实例对应类的Class对象。

public class SynchronizedStaticAndNormal implements Runnable {
    private static SynchronizedStaticAndNormal instance = new SynchronizedStaticAndNormal();
    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            test0();
        } else {
            test1();
        }
    }

    public synchronized static void test0(){
        System.out.println("synchronized static test0()方法运行开始\t" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("synchronized static test0()方法运行结束\t" + Thread.currentThread().getName());
    }

    public synchronized void test1(){
        System.out.println("synchronized test1()方法运行开始\t" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("synchronized test1()方法运行结束\t" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");
    }
}

代码运行结果：
synchronized static test0()方法运行开始	Thread-0
synchronized test1()方法运行开始	Thread-1
synchronized test1()方法运行结束	Thread-1
synchronized static test0()方法运行结束	Thread-0
程序运行结束

7、方法抛出异常后，会释放锁

public class SynchronizedException implements Runnable {
    private static SynchronizedException instance = new SynchronizedException();
    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            test0();
        } else {
            test1();
        }
    }

    public synchronized void test0(){
        System.out.println("synchronized static test0()方法运行开始\t" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        throw new RuntimeException();
        //System.out.println("synchronized static test0()方法运行结束\t" + Thread.currentThread().getName());
    }

    public synchronized void test1(){
        System.out.println("synchronized test1()方法运行开始\t" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("synchronized test1()方法运行结束\t" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");
    }
}

代码运行结果：
synchronized static test0()方法运行开始	Thread-0
Exception in thread "Thread-0" synchronized test1()方法运行开始	Thread-1
java.lang.RuntimeException
	at com.bxp.thread.SynchronizedException.test0(SynchronizedException.java:21)
	at com.bxp.thread.SynchronizedException.run(SynchronizedException.java:8)
	at java.lang.Thread.run(Thread.java:748)
synchronized test1()方法运行结束	Thread-1
程序运行结束

总结：

1）一把锁只能同时被一个线程获取，没有拿到锁的线程必须等待（对应第1、5种情况）

2）每个实例都对应的有自己的一把锁，不同实例之间是互不影响的。例外，锁对象是*.class以及synchronized修饰的是static方法的时候，所有对象共用同一把锁（对应第2、3、4、6种情况）

3）无论方法是正常执行完毕还是方法抛出异常，都会释放锁（对应第7种情况）

补充：当线程进入到一个被synchronized修饰的方法A，A方法调用了没有被synchronized修饰的方法B，线程在运行B方法的时候，是没有线程安全的，此时其他的线程也可以调用方法B，因为方法B没有被synchronized修饰，不是线程安全的。

b15735105314
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程并发访问同一个对象时发生死锁的反思
镜头中的艺术
07-25 5930
来源：http://blog.csdn.net/lezhiyong      背景：SipPhone终端与多个其他设备的用户视频互通，由于Sip终端只能显示一路视频，所以模块A采用轮询方式将多个用户视频发送到sip终端上。模块A同时允许手动打开/关闭其中一个用户的视频，当该用户视频打开时候同时选送到sip终端显示。用户视频采用H264编码，Sip终端接收H263编码视频，所以用户视频需要经过H
多线程执行同一方法问题
芬达矿泉水的博客
04-09 7044
前言当多个线程启动，访问一个实例中的一个方法时，执行情况如何，是等待一个线程执行完成还是同时处理？数据又该如何处理？Java虚拟机运行时数据区的组成由五个部分组成，分别是：方法区，堆，栈，本地方法栈，程序计数器堆：保存所有引用数据的真实信息（共享）栈：基本类型，数据运算，执行堆的指针等（私有）方法区：所有定义的方法等信息（共享）程序计数器：非常小的一块内存，表明程序运行到什么地步、位置（私有）线程...
java 多线程调用单例类的同一个方法
weixin_39793432的博客
10-08 3094
自学入门的.基础不牢靠,最近再遇到前端并发调后台的同一接口时,遇到问题,查资料学习了一下,在此记录, 前端请求到达Web服务器后,Web服务器中有一个线程池,他会从线程池中取一个线程执行请求,通过该线程调用求的Servlet(即Controller,Controller,在Spring中默认为单例, Controller中运用到的Service也是单例),它可以同时被多个请求调用,请求结束后,线...
多线程与并发 - 多线程访问同步方法的7种情况
热门推荐
简单记录一下。
09-14 20万+
不啰嗦，我们直接开始！ 1、两个线程同时访问一个对象的同步方法 代码： public class SynchronizedObjectMethod implements Runnable { static SynchronizedObjectMethod instance = new SynchronizedObjectMethod(); @Override public void run() { method(); } public sy
多线程访问同步方法的7种情况
码农新锐
04-24 883
1、两个线程同时访问一个对象的同步方法 public class SynchroizedObject extends Thread{ static SynchroizedObject instance = new SynchroizedObject(); public static void main(String []args) { Thread t1 =...
面试题：多线程同步方式
qq_45283095的博客
12-04 285
1.使用synchronized 2.阻塞队列 3.原子变量，如AtomicInteger 4.使用volatile 5.使用ReentrantLock 6.使用ThreadLock
多线程高频60道面试题
03-20
8. **多线程同步方法**： - **synchronized**：用于方法或代码块，实现互斥访问，防止数据竞争。 - **Lock接口**：提供更灵活的同步控制，如ReentrantLock。 - **信号量（Semaphore）**：控制同时访问特定资源的...
2023年最新Java高并发多线程面试题
01-23
1. **线程死锁**：线程死锁是多线程环境下的一种状态，其中两个或更多线程相互等待对方释放资源，导致它们都无法继续执行。避免死锁的方法包括资源预分配、避免循环等待、设置超时和死锁检测机制。 2. **线程同步...
NET面试题-多线程编程与线程同步1
08-08
【描述】：本篇文章主要探讨.NET框架下的多线程编程与线程同步相关的面试问题，包括线程与进程的区别、GUI线程访问控件限制、后台线程与前台线程、锁的使用以及线程同步的不同策略。 【标签】：“软件/插件”、...
多线程访问同步方法的7种情况（慕课视频整理）
奈斯菟咪踢呦
09-22 468
一、两个线程同时访问一个对象的同步方法 /** * 1、两个线程同时访问一个对象的同步方法 * peishunwu */ public class SynchroizedObject implements Runnable { static SynchroizedObject instance = new SynchroizedObject(); public static...
面试：线程同步的几种方式
王温暖的博客
12-12 301
1、Synchronize2、Lock、ReentrantLock3、wait/notify4、阻塞队列：LinkedBlockingQueue，ArrayBlockingQueue，SynchronousQueue5、ThreadLocal6、volatile7、原子变量 AtomicBoolean
【Java】多线程访问同步方法的7种情况
要继续努力的孤独的博客
02-14 277
多线程访问同步方法的7种情况前言1.两个线程同时访问一个对象的同步方法2.两个线程访问两个对象的静态方法3.两个线程访问的是synchronized的静态方法4.同时访问同步方法与非同步方法5.访问同一个对象的不同普通同步方法6.同时访问静态synchronized和非静态synchronized方法7.方法抛异常后,会释放锁 前言 synchronized有两种用法：对象锁和类锁。 对象锁又分为...
这一次，让我们完全掌握Java多线程(2/10)
weixin_34268843的博客
03-10 237
多线程不仅是Java后端开发面试中非常热门的一个问题，也是各种高级工具、框架与分布式的核心基石。但是这个领域相关的知识点涉及到了线程调度、线程同步，甚至在一些关键点上还涉及到了硬件原语、操作系统等更底层的知识。想要背背面试题很容易，但是如果面试官一追问就很容易露馅，更不用说真正想搞明白这个问题并应用在实际的代码实践中了。 不用担心！在接下来的一系列文章中将会由浅入深地贯穿这个问题的方方面面，虽然不...
【无标题】校招面试必须会的线程同步（细解）
weixin_44717588的博客
02-04 486
多线程概述 一、多线程的概念 多线程是指程序中包含多个执行单元，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行 。 二、使用多线程的情况 程序需要同时执行两个或多个任务 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。比如用户输入，当用户输入部分占据CPU时，如果一直没有输入，不可能让这一部分一直占据CPU，这个时候会让别的线程上CPU运行 需要一些后台运行的程序时 二、多线程的优缺点（重在缺点） 优点： 提高程序的响应
C# 多线程如何访问同一个数据
m0_74823524的博客
10-09 355
运行下面程序，可以看出thread1中waitOne()只对thread2中的waitOne()起到互斥的作用，但是thread1并不受waitOne()的影响，可以调用多次，只是在调用结束后调用相同次数的ReleaseMutex()就可以。在多线程中，为了使数据保持一致性必须要对数据或是访问数据的函数加锁，在数据库中这是很常见的，但是在程序中大部分都是单线程的程序，所以没有加锁的必要，但是在多线程中，为了保持数据的同步，一定要加锁。将键/值对添加到字典中，或如果Key已存在，更新基于键的现有值的键的值。
开题报告达达宠物认领信息网站的设计与实现 已通过开题答辩的.docx
最新发布
07-25
宠物认领信息网站的主要目的是为寻找宠物的失主和寻找新家的宠物提供一个在线的信息交流平台。通过这个平台，失主可以发布失宠信息，寻找走失或遗弃的宠物；而救助人或组织则可以发布待领养的宠物信息，为那些无家可归的宠物寻找一个永久的归宿。 这样的网站通常会提供一个详细的宠物数据库，包括照片、品种、年龄、健康状况等信息，以便让失主能够方便地找到自己的宠物。同时，网站还会提供一些相关的服务，如失主与救助人之间的在线交流、宠物匹配推荐、领养手续办理等，以帮助双方顺利完成宠物的认领和领养过程。 宠物认领信息网站的目的在于提高失宠找到宠物的几率，减少流浪宠物的数量，并为那些无家可归的宠物提供一个温馨的新家。同时，网站还能促进社会对流浪宠物的关注和保护，提高人们的动物保护意识。
多线程面试精华：线程锁、线程池与同步解析
以上就是关于多线程面试的一些常见问题和知识点，涵盖了并发编程的基本概念、多线程的价值、创建线程的方式、线程同步以及线程池的使用等内容。理解和掌握这些知识对于在Java开发中进行高效、稳定的多线程编程至关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值