synchronized使用情况

最新推荐文章于 2025-12-29 09:00:04 发布
原创 最新推荐文章于 2025-12-29 09:00:04 发布 · 329 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #多线程

本文深入探讨Java中的synchronized关键字在不同场景下的行为，包括多个线程对同一对象或不同对象的访问方式，以及static修饰符如何改变同步效果。通过具体代码示例，展示了线程间的等待、交替执行和同步锁的概念。

synchronized

未加static关键字

1）一对象两线程一方法【等待执行】

两个并发的线程访问同一个类Object中的synchronized同步代码块或者同步方法时，同一时间只能执行一个线程，另一个线程必须等待当前线程执行完才能执行。

import java.util.concurrent.TimeUnit;
public class Sync {
    public synchronized void test1(){
            for ( int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName() + " " + i);
            }
            try {
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    }
    public static void main(String[] args) {
        Sync sync = new Sync();
        Thread thread1 = new Thread("线程A"){
            @Override
            public void run() {
                sync.test1();
            }
        };
        Thread thread2 = new Thread("线程B"){
            @Override
            public void run() {
                sync.test1();
            }
        };
        thread1.start();
        thread2.start();
    }
}

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

2）两对象两线程一方法【交替执行】

对象的创建是以类为模板，两个对象都有自己独立的方法，不同对象，分为两个线程，两个线程访问同一个方法，他们交替进行。

import java.util.concurrent.TimeUnit;

public class Sync {
    public synchronized void test1(){
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Sync sync = new Sync();
        Sync sync1 = new Sync();
        Thread thread1 = new Thread("线程A"){
            @Override
            public void run() {
                sync.test1();
            }
        };
        Thread thread2 = new Thread("线程B"){
            @Override
            public void run() {
                sync1.test1();
            }
        };
        thread1.start();
        thread2.start();
    }
}

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

3）一对象两线程两方法【等待执行】

当一个线程访问了该类中的一个synchronized方法，另一个线程就不能再去访问其他的synchronized方法，只能执行完这一个再去继续执行。

import java.util.concurrent.TimeUnit;


public class Sync {
    public synchronized void test1(){
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void test2(){
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Sync sync = new Sync();
        Sync sync1 = new Sync();
        Thread thread1 = new Thread("线程A"){
            @Override
            public void run() {
                sync.test1();
            }
        };
        Thread thread2 = new Thread("线程B"){
            @Override
            public void run() {
                sync.test2();
            }
        };
        thread1.start();
        thread2.start();
    }
}

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

4）一对象两线程两方法（有一非synchronized方法）【交替执行】

同一对象，当一个线程访问了一个类的synchronized方法，另一个对象访问其他的非synchronized方法，两个线程交替进行。

import java.util.concurrent.TimeUnit;


public class Sync {
    public synchronized void test1(){
        System.out.println(this);
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public  void test2(){
        System.out.println(this);
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Sync sync = new Sync();
        Sync sync1 = new Sync();
        Thread thread1 = new Thread("线程A"){
            @Override
            public void run() {
                sync.test1();
            }
        };
        Thread thread2 = new Thread("线程B"){
            @Override
            public void run() {
                sync.test2();
            }
        };
        thread1.start();
        thread2.start();
    }
}

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

加static关键字

5）一类一对象两线程两方法（一个方法static修饰，一个没有）【交替执行】

同一个类中，一个线程访问了加static的synchronized方法，另一个线程可以访问未加static修饰的synchronized方法，他们交替进行，因为static修饰后锁住的是类，所有对象共享，而没有加static锁住的是对象，只有每个对下那个私有。

import java.util.concurrent.TimeUnit;


public class Sync {
    public synchronized void test1(){
        System.out.println(this);
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static synchronized void test2(){
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Sync sync = new Sync();
        Sync sync1 = new Sync();
        Thread thread1 = new Thread("线程A"){
            @Override
            public void run() {
                sync.test1();
            }
        };
        Thread thread2 = new Thread("线程B"){
            @Override
            public void run() {
                //类调用类方法
                Sync.test2();
            }
        };
        thread1.start();
        thread2.start();
    }
}

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

6）一类两线程两方法【等待执行】

两个都被static修饰的synchronized方法，一个线程只能等待另一个线程执行完成后才能执行。

import java.util.concurrent.TimeUnit;


public class Sync {
    public static synchronized void test1(){
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static synchronized void test2(){
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Thread thread1 = new Thread("线程A"){
            @Override
            public void run() {
                Sync.test1();
            }
        };
        Thread thread2 = new Thread("线程B"){
            @Override
            public void run() {
                //类调用类方法
                Sync.test2();
            }
        };
        thread1.start();
        thread2.start();
    }
}

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

java线程锁synchronized的几种情况
fengchengwu2012的博客
07-11 705
类方法做是在类加载过程中已经打上标记了，类信息存储在jvm的常量池中，而对象的方法锁是在运行动态确定的，因此类方法锁和不同的对象成员方法锁之间不存在竞争关系。在并发情景，能用无锁的数据块就不要用锁，能锁区块，就不要锁整个方法体，能锁对象就不要用类锁。
各种情况下使用synchronized的差别
风团团
09-04 429
这里不做原理分析，列举了7种情况，意在我们使用synchronized时更加有底气 。下面的情况都是围绕这个姑且称为定理的东西来讲的 synchronized作用于方法上，有static的修饰时锁定的是调用这个方法的对象 无static修饰时锁定的是拥有这个方法的类的class 情况1 public class test02 { public static void main(String[] args) { data data1 = new data(); data
Synchronized 同步出现失效
技术基地
05-29 6905
Synchronized 同步出现失效 Synchronized ，大家都知道这个是Java 提供的一种原子性内置锁，其实现原理是通过获取对象的监视器monitor进行来实现同步的，只有当线程获取到对象monitor才能继续执行，否则该线程进行阻塞(等待)。 示例: public class DemoServiceImpl { @Autowired private D...
Synchronized-锁失效问题剖析
Fong灵
11-08 3282
线程锁-Synchronized
Java线程同步
zhicheng_angle的博客
07-28 394
package work2; public class SynchronizedTest implements Runnable { int num = 50; @Override public void run() { // TODO Auto-generated method stub while(true) { ...
Java - 反射机制中，在静态方法上加synchronized，同步对象是什么？
sara_211的博客
03-26 1202
输出是最好的输入，做一个Java学习记录~ 在对象方法前，加上修饰符synchronized，同步对象是当前实例，也就是this啦 那么如果在类方法前，加上修饰符sunchronized，同步对象是什么呢？ 当synchronized修饰静态方法的时候，同步对象就是这个类的类对象。 代码验证如下： package reflection; public class TestReflec...
精选资源
Synchronized 和 Lock 的区别和使用场景
01-20
总结来说，`synchronized`和Lock各有优势，前者使用简单，适用于大多数情况，而后者提供了更高级的功能，适合需要精细控制的并发编程。选择哪种锁机制应根据具体需求和性能考虑。在实际开发中，合理地使用锁机制可以...
Java中使用synchronized关键字实现简单同步操作示例
09-03
下面将详细介绍`synchronized`关键字的三种使用方式：修饰函数、修饰代码块以及修饰静态方法。 1. **synchronized 修饰函数** 当`synchronized`修饰非静态方法时，它会锁定当前对象实例。这意味着，对于同一个对象...
Java多线程中使用synchronized说明
12-22
使用`synchronized`时，需要警惕死锁和活锁的情况。死锁是指两个或多个线程相互等待对方释放资源，导致它们都无法继续执行。活锁则是线程虽然没有阻塞，但由于某种原因不断重试导致无法继续执行。 7. **可重入性**...
Java使用synchronized实现互斥锁功能示例
08-19
Java使用synchronized实现互斥锁功能示例 在Java编程语言中，synchronized关键字是实现互斥锁功能的主要手段。互斥锁是一种机制，用于控制多个线程访问共享资源的顺序，从而避免因为资源竞争而导致的程序错误。在...
Synchronized 同步出现失效的问题
jyworker_1313的博客
12-17 865
Synchronized 同步出现失效的问题
Synchronized锁失效的几种情况
我就说我500的博客
10-27 5328
Synchronized锁失效的几种情况
java synchronized同步方法调用另一个同步方法，锁机制问题
EnjoyInwind的专栏
07-09 5274
要明白两个问题，1.锁的对象是谁，2.谁持有了锁。 假设方法A和B是在同一个类Test中的两个方法。 Test t=new Test(); t.methodB(); 这个时候，methodB方法被调用时，因为加了synchronized ，需要先获得一个锁，这个锁的对象应该是t，也就是当前的这个Test类的实例，而获得锁的东西是线程，也就是说当前线程拿到了t的锁（而不是你说的B方
Java Synchronized 详解
zcyhappy1314的专栏
05-19 679
以下内容是我的摘抄和理解，想学习 synchronized 用法，戳这里就可以了。synchronied ： java 中的一个关键字，是一种同步锁，其主要作用就是用来保证在同一时刻最多只有一个线程执行 synchronied 修饰的代码。根据其修饰对象不同，其锁的范围不同，其修饰对象有以下几种： 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这
同一个类里面两个synchronized方法，两个线程同时访问的问题
suncat的博客
07-29 9883
代码如上所示，MyObject类有两个方法，分别创建两个线程调用方法A和方法B： 会有以下几种情况： 1、两个方法都没有synchronized修饰，调用时都可进入：方法A和方法B都没有加synchronized关键字时，调用方法A的时候可进入方法B； 2、一个方法有synchronized修饰，另一个方法没有，调用时都可进入：方法A加synchronized关键字而方法B没有加...
一个对象的多个synchronized方法多个线程调用
热门推荐
LMR的博客
05-29 1万+
今天遇到一个笔试题，说的是：当一个线程进入一个对象的synchronized方法之后，其它线程能否进入该对象的其他方法？ 答：很明显当其它方法是非synchronized方法时，调用是不受影响的，但当其它方法也是synchronized方法时呢？接下来我们进行实验验证： class Test{ public synchronized void synchronizedMethod...
synchronized使用的正确姿势
蜕变的快乐
07-28 1895
synchronized关键字在java中是用作线程同步的，保障同步区代码的正确执行，同一时间仅有一个线程进入同步区，其原理是使用锁技术，通过竞争，得到锁的线程执行同步区代码，未得到锁的线程自旋、阻塞等待。下面分为四个部分来对synchronized进行分析： 三种使用方式 实例讲解 单例中的使用 原理浅析 请您站稳扶好，开车了… 三种使用方式 分别是修饰实例方法，修饰静态方法，修饰代码块...
Spring Boot AOP （六）架构落地与最佳实践
最新发布
Java、Python、AI、前沿技术等领域的技术总结和经验分享。
12-29 2924
摘要： 本文详细介绍了Spring Boot AOP在企业级项目中的架构落地与最佳实践。通过分析切面分层设计、顺序控制和性能优化等关键点，文章展示了如何构建统一治理横切关注点的核心架构。重点内容包括方法调用链的完整流程（日志、事务、限流、异常处理、性能监控）、切面组合策略（@Order控制执行顺序）以及高级实战示例。文章强调切面单一职责、异常安全和可组合性等设计原则，为企业级AOP应用提供了清晰的技术路线图。
【java入门到放弃】网络
WZDBXHNL的博客
12-28 1288
防火墙既可以是硬件，也可以是软件，本质上是一种，而不是只能对应某一种形态。
synchronized使用
09-06
在引用中，演示了在同步代码块中使用synchronized关键字的情况。在SynchronizedDemo类的method方法中，使用synchronized关键字来同步代码块，以保证线程安全。 引用展示了子类继承父类，并重写了同步方法的情况。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值