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

最新推荐文章于 2022-03-04 10:29:53 发布
原创 最新推荐文章于 2022-03-04 10:29:53 发布 · 671 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨Java中线程同步的多种场景，包括不同对象、静态与非静态方法的同步处理，以及锁的释放机制。通过实例代码，清晰展示线程如何在不同情况下进行互斥访问。

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

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

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

4、同时访问同步方法（synchronized修饰）和非同步方法（没有被synchronized修饰）

5、访问同一个对象的不同的普通同步方法（非静态方法）

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

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

具体解释：

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

一个一个运行

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

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");

    }

    public synchronized void method(){
        System.out.println("我的对象锁的方法修饰符形式，我叫："+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束。");
    }

}

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

同时运行

public class SynchronizedObjectCodeBlock implements Runnable {

    static SynchronizedObjectCodeBlock instance1 = new SynchronizedObjectCodeBlock();
    static SynchronizedObjectCodeBlock instance2 = new SynchronizedObjectCodeBlock();


    @Override
    public void run() {
        synchronized (this) {
            System.out.println("我叫：" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束。");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");

    }
}

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

一个一个运行

public class SynchronizedClassStatic implements Runnable{

    static SynchronizedClassStatic instance1 = new SynchronizedClassStatic();
    static SynchronizedClassStatic instance2 = new SynchronizedClassStatic();

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");

    }

    public static synchronized void method(){
        System.out.println("我是类锁的第一种形式：static形式，我叫："+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束。");
    }
}

4、同时访问同步方法（synchronized修饰）和非同步方法（没有被synchronized修饰）

非同步方法不受到影响

public class SynchronizedYesAndNo implements Runnable {
    static SynchronizedYesAndNo instance = new SynchronizedYesAndNo();

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");

    }

    public synchronized void method1() {
        System.out.println("我是加锁的方法，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束。");

    }

    public void method2() {
        System.out.println("我是没加锁的方法，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束。");

    }
}

5、访问同一个对象的不同的普通同步方法（非静态方法）

一个一个运行

public class SynchronizedYesAndNo implements Runnable {
    static SynchronizedYesAndNo instance = new SynchronizedYesAndNo();

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");

    }

    public synchronized void method1() {
        System.out.println("我是加锁的方法1，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束。");

    }

    public synchronized void method2() {
        System.out.println("我是加锁的方法2，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束。");

    }
}

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

同时运行

public class SynchronizedYesAndNo implements Runnable {
    static SynchronizedYesAndNo instance = new SynchronizedYesAndNo();

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");

    }

    public synchronized static void method1() {
        System.out.println("我是静态加锁的方法1，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束。");

    }

    public synchronized void method2() {
        System.out.println("我是非静态加锁的方法2，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束。");

    }
}

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

抛出异常后，JVM会释放锁

public class SynchronizedYesAndNo implements Runnable {
    static SynchronizedYesAndNo instance = new SynchronizedYesAndNo();

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");

    }

    public synchronized void method1() {
        System.out.println("我是方法1，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        throw new RuntimeException();
//        System.out.println(Thread.currentThread().getName() + "运行结束。");

    }

    public synchronized void method2() {
        System.out.println("我是方法2，我叫：" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束。");

    }
}

C++线程同步几种方法
yy_xzz的博客
06-13 905
在C++中，线程同步是确保多个线程在访问共享资源时能够协调一致的重要概念。
NET面试题-多线程编程与线程同步1
08-08
【描述】：本篇文章主要探讨.NET框架下的多线程编程与线程同步相关的面试问题，包括线程与进程的区别、GUI线程访问控件限制、后台线程与前台线程、锁的使用以及线程同步的不同策略。 【标签】：“软件/插件”、...
多线程访问同步方法的7种情况
码农新锐
04-24 1001
1、两个线程同时访问一个对象的同步方法 public class SynchroizedObject extends Thread{ static SynchroizedObject instance = new SynchroizedObject(); public static void main(String []args) { Thread t1 =...
多线程与并发 - 多线程访问同步方法的7种情况
热门推荐
。
09-14 20万+
不啰嗦，我们直接开始！ 1、两个线程同时访问一个对象的同步方法 代码： public class SynchronizedObjectMethod implements Runnable { static SynchronizedObjectMethod instance = new SynchronizedObjectMethod(); @Override public void run() { method(); } public sy
操作系统面试—进程同步
handsomeKyne
06-23 1145
本文是基于操作系统概念（第七版）第六章的学习总结，不足之处欢迎批评指正。 一、什么是临界区问题？ 临界区是指在该区域中，进程可能改变共同变量、更新一个表、写一个文件等。如果多个进程进入临界区进行修改，那么将会引起混乱。 典型进程的通用结构： do{ 进入区；    临界区； 退出区；   剩余区； }while(true)； 临界区问题的解答必须满足下面三个要求： 1、互斥。
操作系统面试—进程同步（二）
handsomeKyne
06-24 673
本博文是对上一篇博文的继续，不足之处欢迎大家批评指正。 一、首先介绍常见的经典同步问题 1、有限缓冲问题 假定有n个缓冲项，信号量mutex提供对缓冲池访问的互斥要求，并初始化为1。信号量empty和full代表空缓冲项和满缓冲项的个数，信号量empty初始化为n,full初始化为0。 生产者的代码如下： do{ ... //生产出一项 ... wait(empty); wai
多线程面试题之多线程有几种实现方案，分别是什么
kaszxc的博客
10-09 708
1.多线程有几种实现方案，分别是什么 两种。 继承Thread类 实现Runnable接口 扩展一种 实现Callable接口。这个得和线程池结合
嵌入式八股文面试题库资料知识宝典-多线程编程之四——线程的同步.zip
最新发布
04-27
线程同步则是多线程编程中的一个核心概念，它涉及到线程之间如何协调执行，以避免数据竞争、条件竞争等问题，确保数据的一致性和任务的正确执行顺序。在面试过程中，面试官通常会询问应聘者关于线程同步的知识，以此...
多线程面试题
10-12
在计算机科学中，多线程是一种允许一个进程同时执行多个线程的技术，目的是为了提高程序的执行效率。多线程面试题往往会围绕线程的概念、特性、线程安全、锁机制以及多线程编程中可能遇到的问题和解决方案进行提问。...
哈哈iOS多线程面试题
05-19
在探讨iOS多线程的面试题目时，我们首先要明确进程和线程的定义及其关系。进程可以被理解为计算机上一次执行活动的程序，它是操作系统分配资源的基本单元，拥有独立的内存空间和运行所需的全部资源。当我们提到一个...
java培训：多个线程同时访问一个类是否有问题
weixin_45695430的博客
03-04 1215
一.synchronized 1.多个线程同时访问同一个类实例对象的两个同步方法： package synchronizedTest; public class Example1 { private int num = 0 ; (省略getter.setter，后同) public synchronized void method1() { System.out.println("同步方法1进入"); for(int i = 0 ; i<10 ; i++) { System.out.
Java 多线程访问同步方法的七种情况
liqz666的博客
09-27 354
1、两个线程访问一个对象的同步方法 public class SynchronizedObjectMethod3 implements Runnable{ static SynchronizedObject instance=new SynchronizedObject(); @Override public void run() { method(...
多线程访问同步方法的7种情况（慕课视频整理）
奈斯菟咪踢呦
09-22 514
一、两个线程同时访问一个对象的同步方法 /** * 1、两个线程同时访问一个对象的同步方法 * peishunwu */ public class SynchroizedObject implements Runnable { static SynchroizedObject instance = new SynchroizedObject(); public static...
线程访问
weixin_33779515的博客
12-01 115
1、当程序中用到线程时，开辟一个线程花费一段时间去执行程序，当前程序继续往下执行。 转载于:https://blog.51cto.com/yunzhonghe/1718568
面试——多线程访问同步方法的7种情况
qq_43265746的博客
07-06 942
前言：多线程是Java高级部分而同步是多线程的重点，面试的常考题。今天我总结了7种常考题。 1、当两个线程同时访问同一个对象的同步方法： 这种情况上次有类似的例子（对象锁的方法锁）：https://mp.youkuaiyun.com/postedit/85791038 static SynchronizedObectMethod3 intance=new SynchronizedObectMetho...
关于同步访问与异步访问
dianshanban9429的博客
03-23 394
同步： 在一段时间内，只能做一个事情 同步访问：在访问服务器时，客户端只能等待服务器的响应，不能做其他事情，用户体验差 代表场合： 输入网址访问页面 a标记的默认跳转 submit按钮的表单提交 异步： 在一段时间内，可以同时做多个事情 异步访问：向服务器发送请求时，不耽误用户在网页上的其他操作 代表场合： 用户名的重复验证 聊天室 股票走势图 搜...
线程同步（同步对象、同步访问对象）
无幻
07-25 7541
在多线程的情况下，如果存在多个线程要使用同一个资源的情况时，则需要在线程之间进行协调（同步）才能使程序完成预定的工作，而不会出现灾难性的冲突。
多线程面试精华：线程锁、线程池与同步解析
以上就是关于多线程面试的一些常见问题和知识点，涵盖了并发编程的基本概念、多线程的价值、创建线程的方式、线程同步以及线程池的使用等内容。理解和掌握这些知识对于在Java开发中进行高效、稳定的多线程编程至关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值