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

最新推荐文章于 2024-04-24 13:41:08 发布
最新推荐文章于 2024-04-24 13:41:08 发布
阅读量888 收藏 3
点赞数 2
分类专栏： Java基础 文章标签： synchronized 
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31984879/article/details/89504109
版权

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

public class SynchroizedObject extends Thread{

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

    @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()+"运行结束");
    }
}

运行结果：

我的对象锁的方法修饰符形式，我叫Thread-1
Thread-1运行结束
我的对象锁的方法修饰符形式，我叫Thread-2
Thread-2运行结束

同一个实例使用同一把锁，两个线程使用同一把锁，必然有一个处于等待，一个线程执行完成，另一个线程才可以执行。

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

public class SynchroizedObject2 extends Thread{

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

    public static  void main(String []args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
    }

    @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()+"运行结束");
        }
    }


}

运行结果：

我的对象锁的方法修饰符形式，我叫Thread-2
我的对象锁的方法修饰符形式，我叫Thread-3
Thread-2运行结束
Thread-3运行结束

结果线程同时开始，同时结束，之间不会受干扰，因为对象不是同一个，所以不会受干扰。

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

public class SynchroizedObject3 extends Thread{

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

    public static  void main(String []args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
    }

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

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


}

运行结果

我的对象锁的方法修饰符形式，我叫Thread-2
Thread-2运行结束
我的对象锁的方法修饰符形式，我叫Thread-3
Thread-3运行结束

只要方法是静态的，锁对应的就是一把，所以线程是一个执行完成，再去执行下一个线程。

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

public class SynchroizedObject4 implements Runnable {

    static SynchroizedObject4 instance = new SynchroizedObject4();

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

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")) {
            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()+"运行结束");
    }

}

运行结果

我的加锁的方法修饰符形式，我叫Thread-0
我的没加锁的方法修饰符形式，我叫Thread-1
Thread-1运行结束
Thread-0运行结束

线程0和线程1几乎同时开始同时结束，synchronized  关键字只作用于指定的method1方法中，没有加上synchronized  这个关键字方法，不受影响，不会由于其他方法加上synchronized  而受到影响。非同步方法不受到影响。

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

public class SynchroizedObject5 implements Runnable {

    static SynchroizedObject5 instance = new SynchroizedObject5();

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

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")) {
            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 synchronized void method2() {
        System.out.println("我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }

}

运行结果

我叫Thread-0
Thread-0运行结束
我叫Thread-1
Thread-1运行结束

同一个实例中，这两个方法没有办法同时运行，会出现串行的情况。

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

public class SynchroizedObject6 implements Runnable {

    static SynchroizedObject6 instance = new SynchroizedObject6();

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

    @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());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }

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

}

运行结果

我是静态加锁方法，我叫Thread-0
非静态加锁方法，我叫Thread-1
Thread-0运行结束
Thread-1运行结束

运行结果几乎同时运行，同时结束，所指定的锁对象不是同一个锁，所以可以同时运行。

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

方法抛异常后，会释放锁。展示不抛出异常前和抛出异常后的对比：一旦抛出了异常，第二个线程会立刻进入同步方法，意味着锁已经释放。

public class SynchroizedObject7 implements Runnable {

    static SynchroizedObject7 instance = new SynchroizedObject7();

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

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

    public synchronized void method1() {
        System.out.println(" 我是静态加锁方法，我叫"+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(" 非静态加锁方法，我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }

}

运行结果

我是静态加锁方法，我叫Thread-0
 非静态加锁方法，我叫Thread-1
Exception in thread "Thread-0" java.lang.RuntimeException
	at com.test5.SynchroizedObject7.method1(SynchroizedObject7.java:39)
	at com.test5.SynchroizedObject7.run(SynchroizedObject7.java:25)
	at java.lang.Thread.run(Thread.java:748)
Thread-1运行结束

抛出异常之后，不需要手动手动释放锁，由jvm进行释放锁。

 

 

码农新锐
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
多线程并发访问同一个对象时发生死锁的反思
镜头中的艺术
07-25 5933
来源：http://blog.csdn.net/lezhiyong      背景：SipPhone终端与多个其他设备的用户视频互通，由于Sip终端只能显示一路视频，所以模块A采用轮询方式将多个用户视频发送到sip终端上。模块A同时允许手动打开/关闭其中一个用户的视频，当该用户视频打开时候同时选送到sip终端显示。用户视频采用H264编码，Sip终端接收H263编码视频，所以用户视频需要经过H
Java中的多线程你只要看这一篇就够了
aikuangchou2298的博客
05-10 4779
引 如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文的范围之内。 用多线程只有一个目的，那就是更好的利用cpu的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应“多角色”的程序代码，最起码每个角色要给他一个线程吧，否则连实际场景都无法模拟，当然也没法说能用单线程来实现：比如最常见的“生产者，消费者模型”。 很多人都对...
多线程访问同步方法的7种情况（面试常考）
b15735105314的博客
09-05 744
1、两个线程同时访问一个对象的同步方法 public class SynchronizedObjectMethod implements Runnable { private static SynchronizedObjectMethod synchronizedObjectMethod = new SynchronizedObjectMethod(); ...
多线程与并发 - 多线程访问同步方法的7种情况
热门推荐
简单记录一下。
09-14 20万+
不啰嗦，我们直接开始！ 1、两个线程同时访问一个对象的同步方法 代码： public class SynchronizedObjectMethod implements Runnable { static SynchronizedObjectMethod instance = new SynchronizedObjectMethod(); @Override public void run() { method(); } public sy
C#实现多线程的同步方法详解
01-31
### C#实现多线程的同步方法详解 #### 一、引言 在现代软件开发中，多线程编程已经成为了一种常态。特别是在.NET框架下使用C#进行开发时，多线程技术能够显著提高应用程序的性能和响应速度。然而，多线程环境下也...
java 多线程的同步几种方法
08-29
以下将详细解释Java中实现多线程同步的五种方法。 1. ** synchronized 关键字 ** synchronized关键字是Java中最基础的同步机制，它可以保证同一时间只有一个线程执行特定的代码块。synchronized可以应用于方法或...
Windows几种线程同步方法介绍
01-09
系统中的所有线程都要访问系统资源，一个线程霸占某个资源，其他需要该资源的线程不能完成自己的任务；另外如一个线程在读取某块内存中的数据，而另一个线程又正在修改... 　1、多个线程“同时”访问资源，不能破坏资
Linux多线程同步方法
08-13
在Linux系统中，常用的多线程同步方法有两种：互斥量和信号量。 1. 互斥量（Mutex） 互斥量是一种锁机制，它可以保护共享资源，确保同一时间只有一个线程访问数据。互斥量可以通过pthread的互斥接口来实现。例如，...
java多线程的同步方法实例代码
08-30
在上述代码示例中，展示了在没有同步机制的情况下，多线程操作共享数据可能导致的错误。具体来说，当我们有两个线程`t1`和`t2`同时访问并修改同一个银行账户（`Bank`类的`sum`变量）时，由于线程之间的交替执行，...
java并发访问_Java并发编程(03)：多线程并发访问，同步控制
weixin_28755847的博客
02-12 104
一、并发问题多线程学习的时候，要面对的第一个复杂问题就是，并发模式下变量的访问，如果不理清楚内在流程和原因，经常会出现这样一个问题：线程处理后的变量值不是自己想要的，可能还会一脸懵的说：这不合逻辑吧？1、成员变量访问多个线程访问类的成员变量，可能会带来各种问题。public class AccessVar01 {public static void main(String[] args) {Var...
多线程访问同步方法的7种情况（慕课视频整理）
奈斯菟咪踢呦
09-22 468
一、两个线程同时访问一个对象的同步方法 /** * 1、两个线程同时访问一个对象的同步方法 * peishunwu */ public class SynchroizedObject implements Runnable { static SynchroizedObject instance = new SynchroizedObject(); public static...
java 多线程调用单例类的同一个方法
weixin_39793432的博客
10-08 3099
自学入门的.基础不牢靠,最近再遇到前端并发调后台的同一接口时,遇到问题,查资料学习了一下,在此记录, 前端请求到达Web服务器后,Web服务器中有一个线程池,他会从线程池中取一个线程执行请求,通过该线程调用求的Servlet(即Controller,Controller,在Spring中默认为单例, Controller中运用到的Service也是单例),它可以同时被多个请求调用,请求结束后,线...
多线程之并发访问
weixin_33726318的博客
01-29 124
2019独角兽企业重金招聘Python工程师标准>>> ...
(二) 多线程并发访问
橙子博客
03-02 744
1.synchronized同步方法
Java并发编程(03)：多线程并发访问，同步控制
【积累】，是一个长期持续的过程。
03-29 540
多线程学习的时候，要面对的第一个复杂问题就是，并发模式下变量的访问，如果不理清楚内在流程和原因，经常会出现这样一个问题线程处理后的变量值不是自己想要的，可能还会一脸懵的说这不合逻辑吧？...
多线程并发访问解决方案
yj1986333的博客
09-17 231
synchronized关键字主要解决多线程共享数据同步问题。 ThreadLocal使用场合主要解决多线程中数据因并发产生不一致问题。 ThreadLocal和Synchonized都用于解决多线程并发访问。但是ThreadLocal与synchronized有本质的区别。synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程...
文件多进程、多线程访问
最新发布
weixin_45681365的博客
04-24 279
处理多进程和多线程的文件读写操作需要确保对共享资源的访问是同步的，以防止数据竞争和不一致性。
Java多线程：同步方法解决线程安全问题深入解析
"Java多线程中使用同步方法来解决线程安全问题的案例分析" 在Java多线程编程中，线程安全是一个至关重要的概念，特别是在多个线程访问共享资源时。为了确保数据的一致性和完整性，Java提供了多种同步机制，其中之一...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值