多线程访问同步方法的7种情况

最新推荐文章于 2022-06-19 14:53:38 发布
最新推荐文章于 2022-06-19 14:53:38 发布
阅读量149 收藏
点赞数
分类专栏： java 文章标签： java 多线程 锁 synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/killerofjava/article/details/103386326
版权

如果大家想了解synchronized的信息，可以看我的另外一篇博客：https://blog.csdn.net/killerofjava/article/details/103374409
1.两个线程同时访问一个对象的同步方法。

public class SynchronizedObjectMethod3 implements Runnable {
    static SynchronizedObjectMethod3 soMethod=new SynchronizedObjectMethod3();
    @Override
    public void run() {
       method();
    }
    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()+"运行结束");
    }
    public static void main(String[] args) {
        Thread thread01 = new Thread(soMethod);
        Thread thread02 = new Thread(soMethod);
        thread01.start();
        thread02.start();
        while (thread01.isAlive() || thread02.isAlive()){

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

结果：
在这里插入图片描述

原因：因为这两个线程用的都是同一个runnable实例，所以它们拿的是同一把对象锁，既然是同一把锁那么它们自然就窜行执行。

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

public class SynchronizedObjectMethod3 implements Runnable {
    static SynchronizedObjectMethod3 soMethod1=new SynchronizedObjectMethod3();
    static SynchronizedObjectMethod3 soMethod2=new SynchronizedObjectMethod3();
    @Override
    public void run() {
       method();
    }
    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()+"运行结束");
    }
    public static void main(String[] args) {
        Thread thread01 = new Thread(soMethod1);
        Thread thread02 = new Thread(soMethod2);
        thread01.start();
        thread02.start();
        while (thread01.isAlive() || thread02.isAlive()){

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

结果：
在这里插入图片描述
原因：因为这两个线程用的不是同一个runnable实例，所以它们拿的不是同一把对象锁，既然不是同一把锁，那么它们自然就并行执行。
3.两个线程访问的是synchronized的静态方法。

public class SynchronizedClassStatic4 implements  Runnable{
    static SynchronizedClassStatic4 instance1 = new SynchronizedClassStatic4();
    static SynchronizedClassStatic4 instance2 = new SynchronizedClassStatic4();
    @Override
    public void run() {
        method();
    }
    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()+"运行结束");
    }
    public static void main(String[] args) {
        Thread thread01 = new Thread(instance1);
        Thread thread02 = new Thread(instance2);
        thread01.start();
        thread02.start();
        while (thread01.isAlive() || thread02.isAlive()){

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

结果：
在这里插入图片描述
原因：因为访问的方法被synchronized和static关键字修饰，所以不管是不是用的是同一个runnable实例，它们获得的都是同一把类锁，自然是窜行执行。
4.同时访问同步方法和非同步方法。

public class SynchronizedYesOrNo6 implements  Runnable {
    static SynchronizedYesOrNo6 instance = new SynchronizedYesOrNo6();
    @Override
    public void run() {
        if ("Thread-0".equals(Thread.currentThread().getName())){
            method1();
        }else{
            method2();
        }
    }
    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()+"运行结束");
    }
    public static void main(String[] args) {
        Thread thread01 = new Thread(instance);
        Thread thread02 = new Thread(instance);
        thread01.start();
        thread02.start();
        while (thread01.isAlive() || thread02.isAlive()){

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

结果：
在这里插入图片描述

原因：因为没有加锁的方法是可以被任何线程访问的，所以它们并行执行。
5.访问同一个对象的不同的普通同步方法。

public class SynchronizedDifferentMethod7 implements Runnable {
    static SynchronizedDifferentMethod7 instance = new SynchronizedDifferentMethod7();
    @Override
    public void run() {
        if ("Thread-0".equals(Thread.currentThread().getName())){
            method1();
        }else{
            method2();
        }
    }
    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()+"运行结束");
    }
    public static void main(String[] args) {
        Thread thread01 = new Thread(instance);
        Thread thread02 = new Thread(instance);
        thread01.start();
        thread02.start();
        while (thread01.isAlive() || thread02.isAlive()){

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

结果：
在这里插入图片描述

原因：因为用的是同一个runnable实例，所以这两个普通的同步方法用的都是同一把对象锁，自然它们都是窜行执行。

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

public class SynchronizedStaticAndNormal8 implements Runnable {
    static SynchronizedStaticAndNormal8 instance = new SynchronizedStaticAndNormal8();
    @Override
    public void run() {
        if ("Thread-0".equals(Thread.currentThread().getName())){
            method1();
        }else{
            method2();
        }
    }
    public static 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()+"运行结束");
    }
    public static void main(String[] args) {
        Thread thread01 = new Thread(instance);
        Thread thread02 = new Thread(instance);
        thread01.start();
        thread02.start();
        while (thread01.isAlive() || thread02.isAlive()){

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

结果：
在这里插入图片描述
原因；因为获得的锁不同，一个获得的是类锁，二另一个获得的是对象锁，所以它们会并行执行。

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

public class SynchronizedException9 implements Runnable {
    static SynchronizedException9 instance = new SynchronizedException9();
    @Override
    public void run() {
        if ("Thread-0".equals(Thread.currentThread().getName())){
            method1();
        }else{
            method2();
        }
    }
    public  synchronized  void method1(){
        System.out.println("我加锁的方法1，我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        int i=8/0;
        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()+"运行结束");
    }
    public static void main(String[] args) {
        Thread thread01 = new Thread(instance);
        Thread thread02 = new Thread(instance);
        thread01.start();
        thread02.start();
        while (thread01.isAlive() || thread02.isAlive()){

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

结果：
在这里插入图片描述
原因：被synchronized关键字修饰的方法在抛出异常后，jvm会自动的帮我们释放锁，不需要我们手动释放锁。我们可以看到在method1()方法抛出异常后，method2()方法立马执行了。

suixinghero
关注
专栏目录
多线程同步有几种实现方法C语言,线程同步与并发
weixin_28728279的博客
05-23 1677
今天来学习线程同步与并发，我们先来看一下线程之间的几种通信方式：1.线程之间的几种通信方式Event：事件；Critical Section：临界区；Semaphone：信号量；2.Event事件的使用Event是事件处理的机制，全局定义了一个内置标志Flag，如果Flag值为 False，那么当程序执行 event.wait方法时就会阻塞，如果Flag值为True， 那么event.wait 方...
多线程访问同步方法的7种情况（慕课视频整理）
奈斯菟咪踢呦
09-22 478
一、两个线程同时访问一个对象的同步方法 /** * 1、两个线程同时访问一个对象的同步方法 * peishunwu */ public class SynchroizedObject implements Runnable { static SynchroizedObject instance = new SynchroizedObject(); public static...
多线程访问同步方法的7中情况
Megetood的博客
07-25 95
//对象锁，串行 1.两个线程同时访问一个对象的同步方法 2.两个线程同时访问两个对象的同步方法 //类锁，串行 3.两个线程访问的是synchronized的静态方法 //互不不影响，并行 4.同时访问同步与非同步方法 //synchronized使用同一把锁（this），串行 5.访问同一个对象的不同普通同步方法 //并行，一个是类锁，一个是当前对象锁 6.同时访问静态synchronized...
Java 多线程访问同步方法的七种情况
liqz666的博客
09-27 317
1、两个线程访问一个对象的同步方法 public class SynchronizedObjectMethod3 implements Runnable{ static SynchronizedObject instance=new SynchronizedObject(); @Override public void run() { method(...
多线程访问同步方法的7种情况（面试常考）
热爱我的热爱
04-26 604
1、两个线程同时访问一个对象的同步方法 2、两个线程访问的是两个对象的同步方法 3、两个线程访问的是synchronized的静态方法 4、同时访问同步方法（synchronized修饰）和非同步方法（没有被synchronized修饰） 5、访问同一个对象的不同的普通同步方法（非静态方法） 6、同时访问静态synchronized和非静态synchronized方法 7、方法抛异常后...
Windows几种线程同步方法介绍
01-09
系统中的所有线程都要访问系统资源，一个线程霸占某个资源，其他需要该资源的线程不能完成自己的任务；另外如一个线程在读取某块内存中的数据，而另一个线程又正在修改... 　1、多个线程“同时”访问资源，不能破坏资
Python多线程实现同步的四种方式
12-23
以下四种方法是Python中实现多线程同步的常见方式： 1. **锁机制（Lock）** - **Lock** 类是Python `threading` 模块提供的基础同步原语。当线程尝试获取锁时，如果锁已经被其他线程持有，该线程将会被阻塞，直到...
Linux多线程同步方法
08-13
在Linux系统中，常用的多线程同步方法有两种：互斥量和信号量。 1. 互斥量（Mutex） 互斥量是一种锁机制，它可以保护共享资源，确保同一时间只有一个线程访问数据。互斥量可以通过pthread的互斥接口来实现。例如，...
3种多线程实现同步方法
04-03
本篇文章将深入探讨三种在C++中实现多线程同步的方法：事件对象、关键代码段和互斥对象。 首先，我们来看**事件对象**。事件对象是一种信号机制，用于线程间通信和同步。在Windows API中，CreateEvent函数创建一个...
线程同步的四种方式
Lce的专栏
06-19 2万+
线程同步
多线程与并发 - 多线程访问同步方法的7种情况
热门推荐
。
09-14 20万+
不啰嗦，我们直接开始！ 1、两个线程同时访问一个对象的同步方法 代码： public class SynchronizedObjectMethod implements Runnable { static SynchronizedObjectMethod instance = new SynchronizedObjectMethod(); @Override public void run() { method(); } public sy
java多线程同步5种方法
weixin_39214481的博客
05-28 4万+
一、引言前几天面试，被大师虐残了，好多基础知识必须得重新拿起来啊。闲话不多说，进入正题。二、为什么要线程同步因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不...
实现多线程同步访问共享资源两种方式
weixin_34259232的博客
03-02 1642
实现多线程同步访问共享资源两种方式 synchronzied关键字+Object的wait/notify/notifyAll Lock体系+Condition条件谓词 Synchronized 多个线程同步的依次访问它修饰的方法 对象锁或类锁由JVM自动释放。 对象锁 一个类中存在普通成员变量，多个线程中同时运行同一个类实例的实例方法，会共享访问普通成员变量，产生竞争，存在线程安全问题。需用实...
多线程如何实现同步
爱橙子的OK绷的专栏
05-26 2537
在多个线程并发执行访问同一个数据时，如果不采取相应的措施，将会是非常危险的。所谓同步(synchronization)就是指一个线程访问数据时，其它线程不得对同一个数据进行访问，即同一时刻只能有一个线程访问该数据，当这一线程访问结束时其它线程才能对这它进行访问。同步最常见的方式就是使用锁(Lock)，也称为线程锁。锁是一种非强制机制，每一个线程在访问数据或资源之前，首先试图获取(Acquire)锁，
Java多线程（十五）：多线程同步的五种方法
changhenshui1990的博客
08-18 982
一、为什么要线程同步     因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不成功，账户余额是100.取钱成功了，账户余额是0.那到底是哪个呢？很难说清楚。...
java 多线程调用单例类的同一个方法
遇见Android
03-14 8708
开发过程中，遇到此类场景，基础不牢地动山摇，果断网上找文章学习，摘录文章，记录一下： 1，java多线程调用 单例类中一个的方法是不会排队的，因为jvm 在每个线程下，都有一份 对调用方法的引用。 2，多个线程调用的同一个对象的同一个方法： 如果方法里无成员变量，不受任何影响； 如果方法里有成员变量，只有读操作，不受影响，存在赋值操作，有影响 3，多线程调用同一个方法,局
<MFC笔记> 四种线程同步（或互斥）方式小结
EbowTang的练习场
06-10 9484
一，什么是线程同步？ 同步就是协同步调，按预定的先后次序进行运行。如：你说完，我再说。这里的同步千万不要理解成那个同时进行，应是指协同、协助、互相配合。 线程同步是指多线程通过特定的设置（如互斥量，事件对象，临界区）来控制线程之间的执行顺序（即所谓的同步）也可以说是在线程之间通过同步建立起执行顺序的关系，如果没有同步，那线程之间是各自运行各自的！ 二，线程同步的方式和机制： 临
Java中线程同步问题：深度解析synchronized
weixin_41632656的博客
01-15 4957
我们知道，synchronized是为了解决多个线程访问同一个数据时，有可能造成数据前后不一致的现象，例如下面的程序就是数据前后不一致的例子： public class TestSync implements Runnable { Timer timer = new Timer(); public static void main(String[] args) { TestSync
Java多线程同步：五种实现方法解析
"本文主要探讨了Java多线程同步的几种方法，包括为什么需要线程同步以及不同步时可能出现的问题，并给出了相应的示例代码。" 在Java编程中，多线程同步是确保并发执行的线程能正确共享数据的关键技术。当多个线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值