Synchronized的三种写法

最新推荐文章于 2026-06-30 07:30:00 发布
原创 最新推荐文章于 2026-06-30 07:30:00 发布 · 1.5k 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文详细介绍了Java中的`synchronized`关键字，包括其作为同步代码块、实例方法和静态方法的三种使用方式。通过示例代码展示了`synchronized`如何实现线程同步，确保资源的安全访问。同时，文章分析了对象锁与类锁的区别，帮助读者更好地理解和应用`synchronized`进行多线程控制。
Python3.8

Python3.8

Conda
Python

Python 是一种高级、解释型、通用的编程语言，以其简洁易读的语法而闻名，适用于广泛的应用，包括Web开发、数据分析、人工智能和自动化脚本

文章目录

  • 前言
  • 一、synchronized是什么
  • 二、synchronized的三种写法
    • 1、同步代码块
    • 2、在实例方法上使用synchronized
    • 3、在静态方法上使用synchronized
  • 总结




前言

总结一下自己在学习Synchronized 以及它的三种写法。

一、synchronized是什么？

synchronized是由JVM实现的一种互斥同步的一种方式，被synchronized修饰过的程序块在编译前后被编译器生成了monitorenter和monitorexit两个字节码指令。

如果这个方法使用了synchronized的时候，代表它加上了锁，运行此方法的时都要检查它有没有被其他线程正在使用（或者该类的其他同步方法），有的话要等它使用完，没有的话则直接锁定调用者，然后直接运行。它包括两种用法：synchronized方法和synchronized块。



二、synchronized的三种写法




1、同步代码块

代码如下（示例）：

package com.demo;

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc=new MyClass();
        
        Thread t1=new MyThread(mc);
        Thread t2=new MyThread(mc);
        
        t1.setName("t1");
        t2.setName("t2");
        
        t1.start();
        Thread.sleep(1000);//这个睡眠的作用 是为了保证t1线程先执行。
        t2.start();
    }

}

class MyThread extends Thread {
    private MyClass mc;
    
    public MyThread (MyClass mc) {
        this.mc = mc;
    }
    
    public void run(){
        if(Thread.currentThread().getName().equals("t1")) {
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")) {
            mc.doOther();
        }
    }
    
}

class MyClass{
    //synchronized出现再类方法上，表示锁this。
    public synchronized void doSome(){
        System.out.println("doSome 执行开始");
        try {
            Thread .sleep(1000*5);//睡眠五秒
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("doSome 执行结束");
    }
    
    public void doOther() {
        System.out.println("doOther 执行开始");
        System.out.println("doOther 执行结束");
    }
}
doOther方法执行的时候不需要等待被修饰过的doSome方法结束，因为doOther方法没有被synchronized修饰，所以它不用排队等待。

2、在实例方法上使用synchronized

代码如下（示例）：

package com.demo;

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc=new MyClass();
        
        Thread t1=new MyThread(mc);
        Thread t2=new MyThread(mc);
        
        t1.setName("t1");
        t2.setName("t2");
        
        t1.start();
        Thread.sleep(1000);//这个睡眠的作用 是为了保证t1线程先执行。
        t2.start();
    }

}

class MyThread extends Thread {
    private MyClass mc;
    
    public MyThread (MyClass mc) {
        this.mc = mc;
    }
    
    public void run(){
        if(Thread.currentThread().getName().equals("t1")) {
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")) {
            mc.doOther();
        }
    }
    
}

class MyClass{
    //synchronized出现再类方法上，表示锁this。
    public synchronized void doSome(){
        System.out.println("doSome 执行开始");
        try {
            Thread .sleep(1000*5);//睡眠五秒
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("doSome 执行结束");
    }
    
    public synchronized void doOther() {
        System.out.println("doOther 执行开始");
        System.out.println("doOther 执行结束");
    }
}
在两个方法前都加上synchronized修饰，doOther方法执行的时候需要等待doSome方法结束完之后才执行doSome,因为锁被doSome占了，所以要排队等待。 
我们再开启一个线程：package com.demo;

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        //开启两个线程
        MyClass mc1=new MyClass();
        MyClass mc2=new MyClass();
        
        Thread t1=new MyThread(mc1);
        Thread t2=new MyThread(mc2);
        
        t1.setName("t1");
        t2.setName("t2");
        
        t1.start();
        Thread.sleep(1000);//这个睡眠的作用 是为了保证t1线程先执行。
        t2.start();
    }

}

class MyThread extends Thread {
    private MyClass mc;
    
    public MyThread (MyClass mc) {
        this.mc = mc;
    }
    
    public void run(){
        if(Thread.currentThread().getName().equals("t1")) {
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")) {
            mc.doOther();
        }
    }
    
}

class MyClass{
    //synchronized出现再类方法上，表示锁this。
    public synchronized void doSome(){
        System.out.println("doSome 执行开始");
        try {
            Thread .sleep(1000*5);//睡眠5秒
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("doSome 执行结束");
    }
    
    public synchronized void doOther() {
        System.out.println("doOther 执行开始");
        System.out.println("doOther 执行结束");
    }
}doOther方法执行的时候不需要等待doSome方法结束，因为MyClass对象是两个，两把锁，互不干涉。

3、在静态方法上使用synchronized

package com.demo;


public class Demo {
    public static void main(String[] args) throws InterruptedException {
        //开启两个线程
        MyClass mc1=new MyClass();
        MyClass mc2=new MyClass();
        
        Thread t1=new MyThread(mc1);
        Thread t2=new MyThread(mc2);
        
        t1.setName("t1");
        t2.setName("t2");
        
        t1.start();
        Thread.sleep(1000);//这个睡眠的作用 是为了保证t1线程先执行。
        t2.start();
    }

}

class MyThread extends Thread {
    private MyClass mc;
    
    public MyThread (MyClass mc) {
        this.mc = mc;
    }
    
    public void run(){
        if(Thread.currentThread().getName().equals("t1")) {
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")) {
            mc.doOther();
        }
    }
    
}

class MyClass{
    //synchronized出现再类方法上，表示锁this。
    public synchronized static void doSome(){
        System.out.println("doSome 执行开始");
        try {
            Thread .sleep(1000*5);//睡眠5秒
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("doSome 执行结束");
    }
    
    public synchronized static void doOther() {
        System.out.println("doOther 执行开始");
        System.out.println("doOther 执行结束");
    }
}

doOther方法执行的时候不需要等待doSome方法结束，因为静态方法是类锁，不管创建了几个对象，类锁只有一把。




总结

对象锁：1个对象1把锁，100个对象有100把锁。

类锁：100个对象，全部都是这一把锁。

您可能感兴趣的与本文相关的镜像

Python3.8

Python3.8

Conda
Python

Python 是一种高级、解释型、通用的编程语言，以其简洁易读的语法而闻名，适用于广泛的应用，包括Web开发、数据分析、人工智能和自动化脚本

标签
#机器学习 #数据挖掘 #python
多线程基础学习七：使用synchronized实现多线程情况下的访问次数统计
流浪的神明
11-01 1270
前面学习了多线成基础和synchroniezed的基本用法，现在两者结合起来使用，实现一个简单的计数需求。需求多个线程访问某个类，统计类的访问次数并输出。实现正确的写法第一种实现方式：public class SynchronizedCountNum { public static void main (String[] args) { int i = 0; wh
java中synchronized的三种写法详解
我想月薪过万的博客
11-23 2187
预备知识 首先，我们得知道在java中存在三种变量： 实例变量 ==》 存在于堆中 静态变量 ==》 存在于方法区中 局部变量 ==》 存在于栈中 然后，我们得明白，合适会发生高并发不安全 条件1：多线程并发。 条件2：有共享数据。 条件3：共享数据有修改的行为。 具体不安全案例请参考 如下这篇文章：java线程安全问题详解_我想月薪过万的博客-CSDN博客https://blog.csdn.net/qq_41885673/article/details/121431714 在上面这篇文章银
synchronized3种写法
weixin_46143360的博客
10-23 477
方法1 //取款的方法 public synchronized void withdraw(double money) { //这几行代码线程排队，不能并发 //取款之前的余额 /** *缺点：效率低，只能是this,不能是其他对象。不灵活 优点：代码少，节俭 */ //这里共享对象是Account------>this double before = this.getBal
synchronized三中写法以及死锁的概念
qq_45796208的博客
08-26 659
synchronized有三种写法： 第一种：同步代码块 灵活 synchronized（线程共享对象）{ 同步代码块； } /* 线程同步机制的语法是： synchronized(){ //线程同步代码块。 } synchronized后面小括号中传的这个数据是相当关键的。 这个数据必须是多线程共享的数据，才能达到多线程排队。 ()中写什么？ 那要看你...
深入理解 Java 中的 synchronized 代码块
weixin_74268571的博客
06-15 2387
synchronized的工作原理和使用场景，synchronized的最佳实现方式与场景应用，synchronized代码块减小锁粒度，死循环问题，锁对象问题，死锁问题的讲解
synchronized锁（方法锁, 代码块锁）
Lucifer ZHAO
05-16 7357
synchronized锁可以解决线程安全问题，但是相应的，只要是锁，就会带来性能开销，所以尽可能减小锁的范围尤为重要。 synchronized锁无非修饰普通方法，修饰静态方法，修饰代码块，我认为无非就两种（对象锁、类锁），只不过是锁的使用对象不同而已，实际上synchronized锁的作用范围，取决于使用对象的生命周期。接下来简单介绍几种不同影响范围的锁。...
synchronized同步关键字三种写法和开发中如何解决线程安全问题
qq_44705164的博客
01-16 392
文章目录前言一、同步代码块二、在实例方法上使用synchronized三、在静态方法上使用synchronized总结：开发中如何解决线程安全问题第一种方案第二种方案第三种方案 前言 为了保证线程安全，我们可以采用synchronized同步关键字 一、同步代码块 优点：灵活 注意：synchronized关键字后的小括号中填写的一定是线程共享的对象，希望哪些线程进行排队，就填写这些线程的对象。 代码如下（示例）： synchronized(线程共享对象){ 同步代码块; } 二、在实例方法上使用s
Java多线程之生产者-消费者模型的三种写法（Synchronized、ReentrantLock、ArrayBlockingQueue）
弹弹霹雳的博客
11-23 960
通过Java代码来实现多线程的生产者消费者模型
使用两个线程交叉打印奇偶数的几种写法
qq_28619473的博客
05-31 1467
1、使用volatile变量来控制，不需要用锁，效率较高但是比较耗资源 public class CrossNum { public volatile int num = 1; public volatile boolean flag = false; public static void main(String[] args) { Cro...
三种 synchronized 锁方式详解
2401_88060344的博客
03-22 208
/ 自定义锁对象（private final 防止外部修改）synchronized (lock1) { // 只锁 lock1try {synchronized (lock2) { // 锁 lock2，和 lock1 互不干扰// 测试类t1.start();t2.start();执行结果（等待约3秒）核心结论锁对象可以是任意引用类型（推荐用自定义锁）。可以只锁关键代码段，减少锁持有时间，提升并发性能。适合复杂同步场景，比如需要对不同资源分别加锁的场景。
【Java踩坑笔记】16_synchronized锁定的是对象，不是代码块
最新发布
gaochufukanyongren的博客
06-30 276
再看一个更隐蔽的： 二、踩坑现场 场景 1：字符串常量做锁，锁冲突 场景 2：锁对象被重新赋值 场景 3：synchronized 方法锁定范围理解错误 三、原理解析 3.1 synchronized 的锁定本质 synchronized 锁定的是对象（在对象头里记录锁信息），不是代码块。 等价于： 3.2 三种 synchronized 写法对比 写法 锁定对象 说明 指向的对象 最灵活，推荐 （当前实例） 整个方法体加锁 （Class 对象） 类级别的锁
【Java杂项】synchronized 锁的到底是谁？this、Class 和 lock 选择详解
超级苦力怕的博客
06-18 880
本文围绕 Java `synchronized` 的核心问题展开：它到底锁的是方法、对象，还是类？文章从两个线程调用同一个同步方法却不一定互斥的现象切入，讲清普通同步方法锁 `this`、静态同步方法锁 `Class` 对象、同步代码块锁括号里的对象，并用一棵锁选择决策树总结实例锁、类锁和 `private final lock` 的工程用法，帮助你避开“不是同一把锁就保护不住共享数据”的并发坑。
线程安全以及线程同步synchronized
记录点滴
08-10 392
项目放在服务器中，而服务器已经将线程的定义、线程对象的创建，线程的启动等都已经实现了，这些代码我们不需要编写。 最重要的是：编写的程序需要放到一个多线程的环境中，这些数据在多线程并发的环境下是否是安全的。 1、什么时候数据在多线程并发的环境下会存在安全问题？ 要满足三个条件： （1）多线程并发 （2）有共享数据 （3）共享数据有修改行为 满足上边条件会存在线程安全问题。 2、如何解决 排队执行解决线程安全问题。这种机制被称为： "线程同步机制"（就是线程不能并发了，要排队） 3、两个术语.
Volatile 和 synchronized 写法的其他方式
woshijinfeixi的博客
08-16 177
一.Volatile（易变的） 1.Volatile是用来修饰成员变量和静态成员变量的，是为了防止线程从自己 的高速缓存中查找变量的值，而是必须去主存中查找变量的值。 2.他可以保证变量在多个线程之间的可见性，但是不能保证原子性 3.代码如下： static boolean run = true; public static void main(Strin...
Synchronized三种用法
weixin_41050814的博客
11-08 6880
首先我们了解到Java中的线程同步锁可以是任意对象。 这里我们介绍synchronized的三种应用方式： 1.作用于实例方法，当前实例加锁，进入同步代码前要获得当前实例的锁； 2.作用于静态方法，当前类加锁，进去同步代码前要获得当前类对象的锁； 3.作用于代码块，这需要指定加锁的对象，对所给的指定对象加锁，进入同步代码前要获得指定对象的锁。 这三种应用方式接下来分别介绍 synchro...
synchronized理解
starchao
03-22 7756
转载地址：https://blog.csdn.net/javazejian/article/details/72828483 摘取部分方便学习 synchronized的三种应用方式 synchronized关键字最主要有以下3种应用方式，下面分别介绍 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁 修饰静态方法，作用于当前类对象加锁，进入同步代码前要...
synchronized写法及分析，有你想看的！
qq_16607641的博客
03-01 621
文章目录synchronized写法修饰实例方法修饰静态方法修饰代码块使用背景分析两个线程同时访问同一个对象的同步方法两个线程同时访问两个对象的同步方法两个线程同时访问（一个或两个）对象的静态同步方法两个线程分别同时访问（一个或两个）对象的同步方法（加锁）和非同步方法（不加锁）两个线程访问同一个对象中的同步方法，同步方法又调用一个非同步方法两个线程访问同一个对象中的非同步方法，非同步方法又调用一个同步方法两个线程同时访问同一个对象的不同的同步方法两个线程分别同时访问静态synchronized和非静态syn
synchronized三种使用方式
man_8211的专栏
06-08 4023
前言 在多线程并发编程中Synchronized一直是元老级角色，大家都知道synchronized是重量级锁，但是随着Java SE1.6对Synchronized进行了各种优化之后，有些情况下它并不那么重了，与lock相比性能相差并不是很大，还是比较建议同步的时候优先使用synchronized。 三种使用方式 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁 修饰静
Synchronized底层核心原理
小威的博客
10-27 8648
本篇文章是关于并发编程中Synchronized锁的底层核心原理知识记录，由于篇幅原因，下篇文章将介绍各种锁的优化原理。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值