Java-Synchronized(三)-多线程访问同步方法的七种情况

Java线程同步机制详解
最新推荐文章于 2022-11-04 12:12:00 发布
原创 最新推荐文章于 2022-11-04 12:12:00 发布 · 329 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java SE #Java 进阶 #Java-Synchronized

本文深入探讨Java中线程同步的七种关键场景，包括同一对象同步方法、不同对象同步方法、静态同步方法等的访问行为，以及同步方法与非同步方法、异常释放锁的情况。通过具体代码示例，解析串行与并行访问特性。
七种情况
  1. 两个线程同时访问一个对象的同步方法
  2. 两个线程访问的是两个对象的同步方法
  3. 两个线程访问的是synchronized修饰的静态方法
  4. 同时访问同步方法与非同步方法
  5. 访问一个对象的不同的普通同步方法
  6. 同时访问静态synchronized方法和非静态的synchronized方法
  7. 方法抛出异常后，会释放锁
一 | 两个线程同时访问一个对象的同步方法
  1. 两个线程t1和t2
  2. 同一个对象，它们都是Runnabl的同一个实例instance
  3. 一个对象的同步方法，被synchronizd修饰的method

结论：串行

并发与串行其实是不同的概念，在单核CPU里面，所有指令都是串行的，并发指的在某一个时间段内，多个线程执行。与串行相对应的是并行，之后用串行和并行来区别。

public class SynchronizedObjectMethod3 implements Runnable {

    static  SynchronizedObjectMethod3 instance = new SynchronizedObjectMethod3();

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
//        t1.join();
//        t2.join();
        while(t1.isAlive() || t2.isAlive()) {}
        System.out.println("finished");
    }

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

    public synchronized void method() {
        System.out.println("I'm object method lock " + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("I'm object method lock " + Thread.currentThread().getName() + " is over");
    }
}
二 | 两个线程访问的是两个对象的同步方法
  1. 两个线程t1、t2
  2. 两个对象instance1和instance2

尽管同步代码块对象锁是this，但这个this在起作用是两个不同的实例，用lock1也是一样的。

结论：并行

public class SynchronizedObjectCodeBlock2 implements Runnable {

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

    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public static void main(String[] args)  throws InterruptedException{
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
//        t1.join();
//        t2.join();
        while(t1.isAlive() || t2.isAlive()) {}
        System.out.println("finished");
    }

    @Override
    public void run() {
        synchronized (this) {
            System.out.println("I'm object code block lock1 " + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("I'm object code block lock1 " + Thread.currentThread().getName() + " is over");
        }

//        synchronized (lock2) {
//            System.out.println("I'm object code block lock2 " + Thread.currentThread().getName());
//            try {
//                Thread.sleep(3000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println("I'm object code block lock2 " + Thread.currentThread().getName() + " is over");
//        }
    }
}
三 | 两个线程访问的是synchronized修饰的静态方法
public class SynchronizedStaticMethod4 implements Runnable {

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

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
//        t1.join();
//        t2.join();
        while(t1.isAlive() || t2.isAlive()) {}
        System.out.println("finished");
    }

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

    public static synchronized void method() {
        System.out.println("I'm object method lock " + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("I'm object method lock " + Thread.currentThread().getName() + " is over");
    }
}

结论：串行

四 | 同时访问同步方法与非同步方法

结论当然是非同步方法不会受到影响

public class SynchronizedYesOrNo6 implements Runnable{

    static SynchronizedYesOrNo6 instance = new SynchronizedYesOrNo6();

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
//        t1.join();
//        t2.join();
        while(t1.isAlive() || t2.isAlive()) {}
        System.out.println("finished");
    }

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

    public synchronized void method1() {
        System.out.println("I'm lock " + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("I'm lock " + Thread.currentThread().getName() + " is over");
    }

    public void method2() {
        System.out.println("I'm not lock " + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("I'm not lock " + Thread.currentThread().getName() + " is over");
    }
}

试想一下如果本该作为临界资源的变量i，除了在同步代码块内，还在普通方法的地方被修改，会发生什么呢？

public class DisappearRequest1 implements Runnable {

    static DisappearRequest1 instance = new DisappearRequest1();

    static int i = 0;

    public static void main(String[] args) throws InterruptedException{
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }

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

    public synchronized void method1() {
        for(int j=0; j<100000; j++) {
            i++;
        }
    }

    public void method2() {
        for(int j=0; j<100000; j++) {
            i++;
        }
    }
}

i的最后结果是小于200000的…所以临界资源必须进行互斥操作。

五 | 访问一个对象的不同的普通同步方法
public class SynchronizedDifferentMethod7 implements Runnable{

    static SynchronizedDifferentMethod7 instance = new SynchronizedDifferentMethod7();

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
//        t1.join();
//        t2.join();
        while(t1.isAlive() || t2.isAlive()) {}
        System.out.println("finished");
    }

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

    public synchronized void method1() {
        System.out.println("I'm lock " + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("I'm lock " + Thread.currentThread().getName() + " is over");
    }

    public synchronized void method2() {
        System.out.println("I'm not lock " + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("I'm not lock " + Thread.currentThread().getName() + " is over");
    }

}

结论串行：其实相当于是synchronized锁了同一个this对象

六 | 同时访问静态synchronized方法和非静态的synchronized方法

预测：并行

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

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
//        t1.join();
//        t2.join();
        while(t1.isAlive() || t2.isAlive()) {}
        System.out.println("finished");
    }

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

    public static synchronized void method1() {
        System.out.println("I'm static lock " + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("I'm static lock " + Thread.currentThread().getName() + " is over");
    }

    public synchronized void method2() {
        System.out.println("I'm not static " + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("I'm not static " + Thread.currentThread().getName() + " is over");
    }
}

结论：并行

原因：static加锁的对象是该类的类类型，而普通方法锁加锁的对象是this，这显然是两把不同的锁。

章七 | 方法抛出异常后，会释放锁

要使用RuntimeException来抛出异常

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

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
//        t1.join();
//        t2.join();
        while(t1.isAlive() || t2.isAlive()) {}
        System.out.println("finished");
    }

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

    public  synchronized void method1() {
        System.out.println("I'm static lock " + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
//            throw new Exception();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        catch (Exception e) {
//            e.printStackTrace();
//        }
        throw new RuntimeException();
//        System.out.println("I'm static lock " + Thread.currentThread().getName() + " is over");
    }

    public synchronized void method2() {
        System.out.println("I'm not static " + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("I'm not static " + Thread.currentThread().getName() + " is over");
    }
}
总结
  1. 一把锁只能被一个线程所获取，其他线程只能等待
  2. 每个实例都对应有自己的一把锁，类锁就是所有实例的类类型的锁，有同一个类派生而来的实例自然只有一个类类型
  3. 无论发放还是正常执行完毕还是抛出异常，synchronized修饰的都将释放锁
Java使用synchronized修饰方法来同步线程的实例演示
09-02
在Java编程语言中，synchronized关键字用于实现线程同步，以确保多线程环境下的数据一致性。它主要用于控制对共享资源的并发访问，防止多个线程同时进入临界区，可能导致数据不一致或竞态条件的问题。本文将深入探讨...
Java多线程-同步机制解决线程安全问题方式二：同步方法
最新发布
01-30
总之，Java的同步方法是一种有效的解决线程安全问题的手段，它可以确保共享资源在多线程环境中的正确访问和更新。但是，过度使用同步可能会导致性能下降，因此在设计多线程程序时，需要根据具体需求和性能考虑来选择...
Java开发之高并发必备篇（五）——线程安全操作之synchronized
成都汇智动力的博客
09-28 389
上述介绍了synchronized的使用和原理，我们发现虽然synchronized锁实现了并发安全，但是它有点“重”，因为当一个线程访问同步方法或者代码块获取锁了之后，其他的线程都处于等待阻塞状态，浪费CPU的资源，并且频繁的获取和释放锁也消耗CPU的性能等等，所以以前一提到synchronized大家都说它是一个重量级锁。synchronized犹如一把锁，当一个线程访问之后就锁定访问的共享资源代码段，达到互斥的效果，从而保证了线程的安全，并且同一个线程可以获取同一把锁多次，达到可重入的效果。
Java线程：线程的同步-同步方法
weixin_34390996的博客
11-04 144
Java线程：线程的同步-同步方法   线程的同步是保证多线程安全访问竞争资源的一种手段。 线程的同步是Java多线程编程的难点，往往开发者搞不清楚什么是竞争资源、什么时候需要考虑同步，怎么同步等等问题，当然，这些问题没有很明确的答案，但有些原则问题需要考虑，是否有竞争资源被同时改动的问题？   在本文之前，请参阅《Java线程：线程的同步与锁》，本文是在此基础上所写的。   对于同...
Java多线程synchronized几种方式
liupeng_qwert的专栏
06-15 538
1、synchronized三种类型：synchronized instance  method、synchronized  block 及 synchronized static method 2、代码测试：两个不同线程访问同一个类同一个方法，查看输出结果，目标是不希望出现交叉访问 （1）不加synchronized public class NoSyncronize { publi
Java多线程Synchronized静态方法和非静态方法区别
qq_39199837的博客
08-20 493
1.普通方法和普通代码块锁住的是当前实例对象，同个对象调用是同步效果 2.静态方法和以synchronized(class){}的方式锁代码块，锁住的是当前类的class对象，在同个类内，所属线程独占类锁，其他线程阻塞。 ...
当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
Java
01-17 428
分几种情况： 1.其他方法前是否加了synchronized关键字，如果没加，则能。 2.如果这个方法内部调用了wait，则可以进入其他synchronized方法。 3.如果其他个方法都加了synchronized关键字，并且内部没有调用wait，则不能。 4.如果其他方法是static，它用的同步锁是当前类的字节码，与非静态的方法不能同步，因为非静态的方法用的是this。 ...
Java多线程synchronized同步方法详解
08-24
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，以避免数据不一致和竞态条件。本文将深入探讨`synchronized`同步方法在Java多线程环境中的应用。 1. **synchronized 方法与...
6-3 jmu-Java-07多线程-同步访问
cTiebo的博客
11-04 1566
jmu-Java-07多线程-同步访问
java多线程编程之使用Synchronized块同步方法
09-04
Java多线程编程中，`synchronized`关键字是实现线程同步的关键，它可以防止多个线程同时访问共享资源，从而避免数据不一致的问题。在Java中，`synchronized`有两种使用方式：同步方法和同步代码块。 1. 同步方法： ...
多线程之synchronized基础
weixin_44181671的博客
09-08 627
多线程之Synchronized学习笔记Synchronized简介Synchronized 用法多线程访问同步方法的 7 种情况Synchronized性质可重入性质不可中断性质Synchronized的缺陷 Synchronized简介 synchronized 关键字，代表这个方法加锁,相当于不管哪一个线程（例如线程A），运行到这个方法时,都要检查有没有其它线程B（或者C、 D等）正在用这个方法(或者该类的其他同步方法)，有的话要等正在使用synchronized方法的线程B（或者C 、D）运行完这个
JAVA基础多线程（一）synchronized关键字
Coder Wang
04-25 363
synchronizedsynchronized概述基本规则验证规则1验证规则2验证规则3全局锁和对象锁synchronized同步方法和代码块的区别总结 参考了博客：：http://www.cnblogs.com/skywang12345/p/3479202.html synchronized 概述 Java中每一个对象有且仅有一个与之关联的锁，这种锁成为内部锁，内部锁是一种排它锁(又称互斥锁...
深入理解synchronized关键字
tianmlin1的博客
01-26 272
全文概要 本文主要介绍JAVA线程中synchronized关键字的用法。对于synchronized关键字主要包含以下几点： 当一个线程访问某一个对象synchronized修饰的非静态方法或者代码块时，其他线程不允许访问该对象synchronized修饰的相同的方法或者代码块；当一个线程访问某一个对象synchronized修饰的非静态方法或者代码块时，其他线程不允许访问该对象sy
Java 多线程5：synchronized 关键字用法（修饰类，方法，静态方法，代码块）
hutongling的博客
04-07 1948
在 多线程生成的原因（Java内存模型与i++操作解析） 中，介绍了Java的内存模型，从而可能导致的多线程问题。synchronized就是避免这个问题的解决方法之一。除了 synchronized 的方式，还有 lock，condition，volatile，threadlocal，atomicInteger，cas等方式。synchronized 用法它的修饰对象有几种：修饰一个类，其作用的范
synchronize底层原理
a1290320893的博客
04-19 233
1、java代码层面 预备知识：对象在内存中的内存布局 synchronize可以用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。 1、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 2、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非s.
Java（六）线程的同步
weixin_43821392的博客
02-20 148
一、synchronized关键字 （synchronize：使同步的意思） 总结一下有关锁和条件的关键之处： （1）锁用来保护代码片段， 任何时刻只能有一个线程执行被保护的代码。 （2）锁可以管理试图进入被保护代码段的线程。 （3）锁可以拥有一个或多个相关的条件对象。 （4）每个条件对象管理那些已经进入被保护的代码段但还不能运行的线程。 1.synchronized标记方法 在Java中，可...
 jmu-Java-07多线程-同步访问 (10分)
嗯呢嗯呢的博客
06-06 6495
jmu-Java-07多线程-同步访问(10分) 现已有Account类，拥有属性:private int balance方法: 相应的getter方法。 要求为该类编写：void deposit(int money)//存钱，在余额的基础上加上moneyvoid withdraw(int money)//取钱，在余额的基础上减去money 注意： 取钱时如果balance<0的时候，会抛出异常。在多线程情况下，如只有一个存钱的线程，但是有多个取钱的线程，很可能会抛出异常。 需要编写完...
多线程访问 synchronized 方法的八种具体情况
乌鲁木齐001号程序员
04-11 519
概述 情况一：两个线程同时访问一个对象的 synchronized 方法，同步执行； 情况二：两个线程访问的是两个对象的 synchronized 方法，并行执行； 情况三：两个线程同时访问一个 synchronized 静态方法，同步执行； 情况四：两个线程同时访问 synchronized 方法与非 synchronized 方法，并发执行； 情况五...
多线程与并发 - 多线程访问同步方法的7种情况
热门推荐
。
09-14 20万+
不啰嗦，我们直接开始！ 1、两个线程同时访问一个对象的同步方法 代码： public class SynchronizedObjectMethod implements Runnable { static SynchronizedObjectMethod instance = new SynchronizedObjectMethod(); @Override public void run() { method(); } public sy
Java多线程：Synchronized同步类方法解析
总结来说，`synchronized`关键字在Java多线程编程中起到至关重要的作用，它提供了一种机制来保护共享资源不受并发访问的影响，从而避免数据不一致性和线程安全问题。无论是同步实例方法还是静态方法，都需要注意锁的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值