java synchronized关键字

最新推荐文章于 2025-06-10 17:46:18 发布
置顶 最新推荐文章于 2025-06-10 17:46:18 发布
阅读量482 收藏
点赞数
分类专栏： 多线程 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/learner_and_thinker/article/details/78072443
版权
本文详细介绍了Java中的synchronized关键字，包括其作用、用法及特点。synchronized关键字可用于实现线程间的互斥访问、保证共享变量的修改可见性和解决重排序问题。文章通过示例代码演示了synchronized在修饰普通方法、静态方法和代码块中的具体应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

synchronized关键字用于多线程同步，其具有以下作用：
1. 确保线程互斥的访问同步代码
2. 保证共享变量的修改能够及时可见
3. 有效解决重排序问题

其主要有三种用法：
1. 修饰普通方法
2. 修饰静态方法
3. 修饰代码块

测试代码：

public class C{

    private static ArrayList<Integer> list=new ArrayList<>();

    public void noSyn() {
        for(int i=0;i<5;++i){
            System.out.println(Thread.currentThread().getName()+" "+"no Syn");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }

    }

    public synchronized void normalSyn1() {
        for(int i=0;i<5;++i){
            System.out.println(Thread.currentThread().getName()+" "+"normal Syn1 ");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }

    }

    public static void noSynStatic() {
        for(int i=0;i<5;++i){
            System.out.println(Thread.currentThread().getName()+" "+"no Syn static");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }

    }

    public static synchronized void staticSyn() {
        for(int i=0;i<5;++i){
            //list.add(i);
            System.out.println(Thread.currentThread().getName()+" "+"static syn "+list);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }

    }

    public void staticString1(){
        synchronized (list) {
            for(int i=0;i<5;++i){
                list=new ArrayList<>();
                System.out.println(Thread.currentThread().getName()+" "+"static integer1 "+list);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                }
            }
        }
    }

    public void staticString2(){
        synchronized (list) {
            for(int i=0;i<5;++i){
                System.out.println(Thread.currentThread().getName()+" "+"static integer2 "+list);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                }
            }
        }
    }

    public synchronized void normalSyn2() {
        for(int i=0;i<5;++i){
            System.out.println(Thread.currentThread().getName()+" "+"normal Syn2");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }
    }
}

其特点如下：
1.synchronized修饰普通方法methodA时，在不同线程中使用同一对象调用方法methodA，这样会导致先获取该对象锁的线程先执行，其他线程受阻塞。

public static void main(String []ags) throws Exception{
        final C c=new C();
        final C c1=new C();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根
                c.normalSyn();  
            }
        }).start();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根       
                c.normalSyn();
            }
        }).start();

    }

这里写图片描述

2.synchronized修饰普通方法methodA、methodB时，在不同线程中使用同一对象。在线程A中调用methodA，在线程B中调用methodB，这样会导致先获取对象锁的线程先执行，其他线程受阻塞。这表明，synchronized修饰普通方式时，锁住的是对象。当某一个线程获取到该对象锁时，其他线程就不能执行需要该对象锁的方法（即synchronized修饰的普通方法，代码块上为this的synchronized代码块）

public static void main(String []ags) throws Exception{
        final C c=new C();
        final C c1=new C();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根
                c.normalSyn1(); 
            }
        }).start();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根       
                c.normalSyn2();
            }
        }).start();

    }

结果：
这里写图片描述

3.synchronized修饰普通方法methodA时，在不同线程中使用不同对象调用该方法，这样会导致各线程按CPU调度进行，没有发送阻塞。这表明，不同对象有不同的对象锁，互不影响。

public static void main(String []ags) throws Exception{
        final C c=new C();
        final C c1=new C();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根
                c.normalSyn1(); 
            }
        }).start();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根       
                c1.normalSyn1();
            }
        }).start();

结果：
这里写图片描述

4.synchronized修饰普通方法methodA时，在不同线程中同一对象，在线程A中调用methodA，在线程B中调用非synchronized的方法methodB，这样会导致各线程按CPU调度进行，没有发送阻塞。这表明，没有锁的方法不会受到对象锁影响。

public static void main(String []ags) throws Exception{
        final C c=new C();
        final C c1=new C();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根
                c.normalSyn1(); 
            }
        }).start();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根       
                c.noSyn();
            }
        }).start();

    }

结果：
这里写图片描述

5.synchronized修饰静态方法时，在不同线程中使用该类的不同对象调用该方法时，这样会导致先获取类锁的线程先执行，其他线程阻塞。

public static void main(String []ags) throws Exception{
        final C c=new C();
        final C c1=new C();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根
                c.staticSyn();
            }
        }).start();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根       
                c1.staticSyn();
            }
        }).start();

    }

结果：
这里写图片描述

6.synchronized修饰普通方法methodA、静态方法methodB时，在不同线程中使用同一对象。在线程A中调用methodA，在线程B中调用methodB，这样会导致线程按CPU调度进行，各不影响。因为普通方法锁的是对象，静态方法锁的是类，两者互不干扰。

public static void main(String []ags) throws Exception{
        final C c=new C();
        final C c1=new C();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根
                c.staticSyn();
            }
        }).start();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根       
                c.normalSyn1();
            }
        }).start();

    }

结果：
这里写图片描述

7.在方法methodA中用synchronized修饰代码块上的静态变量，synchronized修饰静态方法methodB，在不同线程中使用同一对象。在线程A中调用methodA，在线程B中调用methodB，这样会导致线程按CPU调度进行，各不影响。这表明虽然synchronized修饰的是静态变量，但它锁的是该变量；而synchronized修饰静态方式锁的是类，这样它们还是会互不影响。所以在synchronized锁变量时，必须要注意其在其他方法中的控制。
C类中方法staticSyn有所改变：

public static synchronized void staticSyn() {
        for(int i=0;i<5;++i){
            System.out.println(Thread.currentThread().getName()+" "+"static syn "+list);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }

    }
public static void main(String []ags) throws Exception{
        final C c=new C();
        final C c1=new C();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根
                c.staticString2();
            }
        }).start();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根       
                c.staticSyn();
            }
        }).start();

    }

结果：
这里写图片描述

8.在方法methodA中用synchronized修饰代码块上的静态变量，在方法methodB中用synchronized修饰代码块上的同样的静态变量，在不同线程中使用同一对象。在线程A中调用methodA，在线程B中调用methodB，这样会导致先获取类锁的线程先执行，其他线程阻塞。前提是在先执行的线程中没有改变该静态变量的内存地址。若改变了，那么线程会按CPU调度运行。因为synchronized锁的是变量的那个内存位置，若后面改变了该变量的内存位置，在其他方法中比对当前位置与被锁位置不一致，则会执行。

public static void main(String []ags) throws Exception{
        final C c=new C();
        final C c1=new C();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根
                c.staticString1();      
            }
        }).start();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根       
                c.staticString2();
            }
        }).start();

    }

结果：
这里写图片描述

顺序改变一下：（先执行的线程没有改变地址）

public static void main(String []ags) throws Exception{
        final C c=new C();
        final C c1=new C();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根
                c.staticString2();          
            }
        }).start();
        new Thread(new Runnable() {         
            @Override
            public void run() {
                // TODO 自动生成的方法存根       
                c.staticString1();
            }
        }).start();

    }

结果：
这里写图片描述

java synchronized关键字的用法
果酱 の 博客
07-24 3050
在Java中，多线程编程是一项常见的任务。为了保证多线程程序的正确性和一致性，我们需要使用同步机制来控制线程的访问。synchronized关键字是Java中最基本的同步机制之一，它可以用于修饰方法或代码块，实现线程的互斥访问和共享数据的同步操作。本文将详细介绍synchronized关键字的用法，以及它在多线程编程中的应用。
Java synchronized关键字实现线程同步
WYSCODER的博客
04-02 6651
synchronized关键字实现线程同步
【java】synchronized关键字详解
Wang_Zimeng的博客
05-15 808
锁类型锁对象同步范围适用场景对象锁对象实例，以及对象调用方法当前实例的线程非静态的示例方法类锁Class对象所有实例的对象静态变量保护或全局操作，例如数据库连接池的初始化同步代码块显示指定的对象代码块包含的区域同步耗时操作中的关键部分对象头与锁状态：通过 Mark Word 记录锁状态，支持偏向锁、轻量级锁、重量级锁的升级。锁升级机制：根据线程竞争动态调整锁级别，平衡性能与安全性。
java中synchronized关键字
龙空白白的博客
06-10 4152
synchronized是java中的一个关键字，在中文中为同步，也被称之为’同步锁’,以此来达到多线程并发访问时候的并发安全问题，可以用来修饰代码块、非静态方法。静态方法等； 修饰代码块时:给当前指定的对象加锁 修饰非静态方法时:作用于当前实例加锁 修饰静态方法时:作用于当前类对象加锁 synchronized在java内存模型中的主要作用 原子性:通过monitorenter和monitorexit指令,保证被synchronized修饰的代码在同一时间只能被一个线程访问，在锁未释放之前，无法被其他线程
深入理解 Java 中的 synchronized 关键字
m0_74750751的博客
04-20 1358
目录1.基本概念什么是 synchronized？ 可重入性2. 使用场景2.1 实例方法同步2.2 静态方法同步 2.3 代码块同步 3.锁机制3.1 对象锁 vs 类锁3.2 锁升级机制 3.3 自适应自旋锁自旋锁自适应自旋锁3.4 锁消除与锁粗化4.注意事项 4.1 避免过度同步4.2 理解锁的升级过程4.3 注意死锁问题4.4 考虑使用更高级别的并发工具在多线程编程中，确保数据的一致性和正确性是至关重要的。Java 提供了多种机制来实现这一点，其中最基础和常用的便是 关键字。本文将详细介绍 的各
Java 中的 synchronized 关键字详解
云扬的博客
11-27 1412
在 Java 中，`synchronized` 关键字是一个非常重要的同步机制，用于确保在多线程环境下，同一时刻只有一个线程可以执行某个方法或代码块。本文将详细介绍 `synchronized` 关键字的三种应用方式、其作用以及注意事项。
Java中的synchronized关键字
林隐的博客
11-30 1551
Java中的synchronized关键字
Java中synchronized关键字的作用及使用场景
Java开发者，专注后端技术分享，深耕框架实战与架构优化，持续输出优质技术干货。
04-23 966
关键字在Java中扮演着重要的角色，通过提供互斥锁、对象锁和类锁、内存可见性以及锁升级等功能，确保了多线程环境下的数据一致性和系统稳定性。对于静态方法或静态代码块，锁住的是类的Class对象。使用场景：在电商平台的商品库存管理中，可以使用对象锁来控制对单个商品对象的访问，或者使用类锁来控制对整个库存列表的访问。它通过内置的锁机制来协调多线程对共享资源的访问，确保数据的一致性和完整性。使用场景：在高并发环境下，如大型在线游戏服务器，通过锁升级机制可以有效降低线程切换的成本，提高系统的吞吐量。
Java中的synchronized关键字的作用
05-22 387
关键字是用于控制多线程并发访问共享资源的有效手段，它提供了一种内置锁机制，确保同一时间只有一个线程可以执行某个代码块或方法，从而防止数据的不一致性和脏读。下面，我将从技术难点、面试官关注点、回答吸引力以及代码举例四个方面，详细解释。，我们可以确保多线程并发访问共享资源时的数据一致性和正确性。同时，我们也需要注意。修饰，因此它们在同一时间只能被一个线程访问。这样就保证了计数器的线程安全性。可能带来的性能开销和潜在问题，并采取相应的措施进行优化和解决。是Java中实现线程安全的重要手段之一。
java的synchronized 关键字详解
m0_57659908的博客
04-13 1883
java的synchronized 关键字详解，介绍了synchronized 的原理，synchronized 的优化，即偏向锁，轻量级锁，自旋锁，锁消除，锁加重
Java synchronized关键字和Lock接口实现原理
08-25
Java synchronized关键字和Lock接口实现原理 Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发问题。下面我们将详细介绍 synchronized 关键字和 Lock 接口的实现原理。...
java synchronized关键字原理、自定义一把锁来实现同步等
02-19
### Java synchronized 关键字原理与自定义锁实现详解 #### 一、Java synchronized 关键字原理 `synchronized` 是 Java 中的关键字之一，用于实现线程间的同步控制，确保共享资源的安全访问。它主要应用于以下两种...
Java synchronized关键字使用方式及特性解析
08-25
Java中的synchronized关键字是一种实现锁的方式，它是在JVM层面实现的非公平锁。synchronized关键字可以用于实现线程同步，以下是使用synchronized的四种方式： 1. 作用在方法上，保证了访问同一个对象的同一个方法...
简单了解Java synchronized关键字同步
08-25
Java synchronized关键字同步详解 Java 中的 synchronized 关键字是用于实现线程同步的重要机制。下面我们将详细介绍 synchronized 关键字的使用方法和原理。 synchronized 关键字的作用 synchronized 关键字可以...
Java循环编程常见错误与优化实践
最新发布
静水深流
06-10 352
值得注意的是，基础的静态分析诊断（如"变量未使用"）无法检测此类问题，因为循环变量。该实现完全封装了索引操作，消除了客户端代码中显式使用索引的风险。建议在代码审查时特别关注循环体内索引变量的使用一致性，并针对边界情况（如空数组、单元素数组、多元素同值数组）设计专项测试用例。），将导致严重的无限循环问题。在需要逆向遍历集合时，开发者常犯的关键错误是修改循环条件后忘记调整递增/递减操作。开发者在循环结构中常犯的一个典型错误是：虽然正确编写了循环结构，但在循环体内错误地使用常量索引（如。停止更新，引发无限循环。
极限复习c++
2302_76213070的博客
06-05 2372
快速过一遍必背代码（类、多态、模板）和简答题答案，强化肌肉记忆！祝考试顺利，代码全 AC！
Linux入门(十五)安装java&安装tomcat&安装dotnet&安装mysql
will_net的博客
06-09 287
如果只需要运行 .NET Core 应用（不开发），安装 Runtime。原因：yum 安装 Tomcat 时，默认不会自动部署 ROOT 应用。问题:tomcat 可以访问，但是显示404。解决方案：安装tomcat-webapps。下载 MySQL Yum 仓库安装包。验证仓库是否添加成功。
11《Java 类加载机制：从动态加载到热修复的底层秘密》
qq_62682600的博客
06-08 994
Java 类加载机制在运行期完成类的加载、连接与初始化，牺牲部分性能换灵活性，支持热修复、插件化等。其生命周期含 7 阶段，初始化有 5 种强制触发场景，动态性是热修复等技术的底层基础。
Java synchronized关键字深度解析
"本文详细解析了Java中的`synchronized`关键字，它是Java实现线程同步的重要机制。通过使用`synchronized`，可以确保多线程环境下的数据一致性与安全性。它可应用于对象方法、静态方法以及代码块，确保同一时间只有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值