JAVA同步锁 synchronized(this)、synchronized(class)与synchronized(Object)的区别

最新推荐文章于 2024-04-01 17:44:34 发布
最新推荐文章于 2024-04-01 17:44:34 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： Java 文章标签： java 开发语言 java-ee
本文为博主原创文章，未经博主允许不得转载。联系微信：Baiman_Ber
本文链接：https://blog.csdn.net/Ber_Bai/article/details/125172097
版权 
/**
 * synchronized(this) 只能锁当前对象
 * synchronized(A.class) 锁类，对类的所有实例生效
 */

public class Synchronized {
    public void method1() { // 锁当前对象
        try {
            synchronized (this) {
                System.out.println("this   method1 start time=" + System.currentTimeMillis());
                Thread.sleep(2000);
                System.out.println("this   method1 end time=" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    public synchronized void method2() { // 与method1存在竞争关系
        System.out.println("       method2 start time=" + System.currentTimeMillis());
        System.out.println("       method2 end time=" + System.currentTimeMillis());
    }

    public void method3() { // 锁类，对类的所有实例生效
        synchronized (Synchronized.class) {
            try {
                System.out.println("class  method3 start time=" + System.currentTimeMillis());
                Thread.sleep(4000);
                System.out.println("class  method3 end time=" + System.currentTimeMillis());
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static synchronized void method4() { // 与method3存在竞争关系
        System.out.println("static method4 start time=" + System.currentTimeMillis());
        System.out.println("static method4 end time=" + System.currentTimeMillis());
    }

}

class Thread1 extends Thread {
    private Synchronized objectService;

    public Thread1(Synchronized objectService) {
        super();
        this.objectService = objectService;
    }

    @Override
    public void run() {
        super.run();
        objectService.method1();
    }
}

class Thread2 extends Thread {
    private Synchronized objectService;

    public Thread2(Synchronized objectService) {
        super();
        this.objectService = objectService;
    }

    @Override
    public void run() {
        super.run();
        objectService.method2();
    }
}

class Thread3 extends Thread {
    private Synchronized objectService;

    public Thread3(Synchronized objectService) {
        super();
        this.objectService = objectService;
    }

    @Override
    public void run() {
        super.run();
        objectService.method3();
    }
}

class Thread4 extends Thread {
    private Synchronized objectService;

    public Thread4(Synchronized objectService) {
        super();
        this.objectService = objectService;
    }

    @Override
    public void run() {
        super.run();
        objectService.method4();
    }
}

class MainTest {
    public static void main(String[] args) {
        Synchronized service = new Synchronized();

        new Thread1(service).start();
        new Thread2(service).start();
        new Thread3(service).start();
        new Thread4(service).start();
    }
}

输出结果：

在这里插入图片描述
从时间线可以看出method1和method2、method3和method4存在竞争关系。
当一个线程访问Synchronized类的一个synchronized (this)同步代码块时，其它线程对同一个Synchronized类中其它的synchronized ()同步方法的访问将是堵塞；访问synchronized (Synchronized.class)同步代码块时， static synchronized同步方法的访问将是阻塞，这说明synchronized (this)和synchronized ()同步方法、synchronized (Synchronized.class)同步代码块和 static synchronized同步方法使用的对象监视器是一个。

synchronized同步方法和synchronized(this)同步代码块

/**
 * synchronized(this)锁定当前对象
 */

public class SynchronizedThis {
    public void methodA() {
        try {
            synchronized (this) {
                System.out.println("this methodA 线程名称:" + Thread.currentThread().getName() + " begin time=" + System.currentTimeMillis());
                for (int i = 1; i <= 2; i++) {
                    System.out.println("this methodA 线程名称:" + Thread.currentThread().getName() + "-->i=" + i);
                    Thread.sleep(100);
                }
                System.out.println("this methodA 线程名称:" + Thread.currentThread().getName() + " end  time=" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void methodB() {
        synchronized (this) {
            try {
                System.out.println("this methodB 线程名称:" + Thread.currentThread().getName() + " begin time=" + System.currentTimeMillis());
                for (int i = 1; i <= 2; i++) {
                    System.out.println("this methodB 线程名称:" + Thread.currentThread().getName() + "-->i=" + i);
                    Thread.sleep(100);
                }
                System.out.println("this methodB 线程名称:" + Thread.currentThread().getName() + " end  time=" + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void methodC() {
        try {
            System.out.println("     methodC 线程名称:" + Thread.currentThread().getName() + " begin time=" + System.currentTimeMillis());
            for (int i = 1; i <= 2; i++) {
                System.out.println("     methodC 线程名称:" + Thread.currentThread().getName() + "-->i=" + i);
                Thread.sleep(100);
            }
            System.out.println("     methodC 线程名称:" + Thread.currentThread().getName() + " end  time=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThisThreadA extends Thread {
    private SynchronizedThis synchronizedThis;

    public ThisThreadA(SynchronizedThis synchronizedThis) {
        super();
        this.synchronizedThis = synchronizedThis;
    }

    @Override
    public void run() {
        super.run();
        synchronizedThis.methodA();
    }
}

class ThisThreadB extends Thread {
    private SynchronizedThis synchronizedThis;

    public ThisThreadB(SynchronizedThis synchronizedThis) {
        super();
        this.synchronizedThis = synchronizedThis;
    }

    @Override
    public void run() {
        super.run();
        synchronizedThis.methodB();
    }
}

class ThisThreadC extends Thread {
    private SynchronizedThis synchronizedThis;

    public ThisThreadC(SynchronizedThis synchronizedThis) {
        super();
        this.synchronizedThis = synchronizedThis;
    }

    @Override
    public void run() {
        super.run();
        synchronizedThis.methodC();
    }
}

class ThisMainTest {
    public static void main(String[] args) {
        SynchronizedThis service = new SynchronizedThis();
        ThisThreadA a = new ThisThreadA(service);
        a.setName("ThreadA");
        a.start();
        ThisThreadB b = new ThisThreadB(service);
        b.setName("ThreadB");
        b.start();
        ThisThreadC c = new ThisThreadC(service);
        c.setName("ThreadC");
        c.start();
    }
}

输出结果
在这里插入图片描述

多个线程调用同一个对象中的不同名称的synchronized同步方法或synchronized(this)同步代码块时，是同步的。

synchronized同步方法和synchronized(this)同步代码块是相互竞争关系

  1. 对其它的synchronized同步方法或synchronized(this)同步代码块调用是堵塞状态；
  2. 同一时间只有一个线程执行synchronized同步方法或synchronized(this)同步代码块中的代码。

静态同步synchronized方法

/**
 * 静态同步synchronized方法
 * synchronized应用在static方法上，那是对当前对应的*.Class进行持锁。
 */
public class SynchronizedStatic {
    public synchronized static void methodA() {
        try {
            System.out.println("static methodA 线程名称:" + Thread.currentThread().getName() + " begin times:" + System.currentTimeMillis());
            for (int i = 1; i <= 5; i++) {
                System.out.println("static methodA 线程名称:" + Thread.currentThread().getName() + "-->i=" + i);
                Thread.sleep(1000);
            }
            System.out.println("static methodA 线程名称:" + Thread.currentThread().getName() + " end   times:" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized static void methodB() {
        System.out.println("static methodB 线程名称:" + Thread.currentThread().getName() + " begin times:" + System.currentTimeMillis());
        System.out.println("static methodB 线程名称:" + Thread.currentThread().getName() + " end   times:" + System.currentTimeMillis());
    }
}

class StaticThreadA extends Thread {
    @Override
    public void run() {
        SynchronizedStatic.methodA();
    }
}

class StaticThreadB extends Thread {
    @Override
    public void run() {
        SynchronizedStatic.methodB();
    }
}

class StaticMainTest {
    public static void main(String[] args) {
        StaticThreadA a = new StaticThreadA();
        a.setName("ThreadA");
        a.start();
        StaticThreadB b = new StaticThreadB();
        b.setName("ThreadB");
        b.start();
    }
}

输出结果
在这里插入图片描述
synchronized应用在static方法上，那是对当前对应的*.Class进行持锁，与同步synchronized(*.class)代码块作用一样。
对比下面代码进行验证

synchronized(*.class)代码块

/**
 * synchronized(*.class)代码块
 * 同步synchronized(*.class)代码块的作用其实和synchronized static方法作用一样。
 * Class锁对类的所有对象实例起作用。
 */
public class SynchronizedClass {
    public void methodA() {
        try {
            synchronized (SynchronizedClass.class) {
                System.out.println("class methodA 线程名称:" + Thread.currentThread().getName() + " begin times:" + System.currentTimeMillis());
                for (int i = 1; i <= 5; i++) {
                    System.out.println("class methodA 线程名称:" + Thread.currentThread().getName() + "-->i=" + i);
                    Thread.sleep(1000);
                }
                System.out.println("class methodA 线程名称:" + Thread.currentThread().getName() + " end   times:" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void methodB() {
        synchronized (SynchronizedClass.class) {
            System.out.println("class methodB 线程名称:" + Thread.currentThread().getName() + " begin times:" + System.currentTimeMillis());
            System.out.println("class methodB 线程名称:" + Thread.currentThread().getName() + " end   times:" + System.currentTimeMillis());
        }
    }
}

class ClassThreadA extends Thread {
    private SynchronizedClass objectService;

    public ClassThreadA(SynchronizedClass objectService) {
        super();
        this.objectService = objectService;
    }

    @Override
    public void run() {
        objectService.methodA();
    }
}

class ClassThreadB extends Thread {
    private SynchronizedClass objectService;

    public ClassThreadB(SynchronizedClass objectService) {
        super();
        this.objectService = objectService;
    }

    @Override
    public void run() {
        objectService.methodB();
    }
}

class ClassMainTest {
    public static void main(String[] args) {
        SynchronizedClass service = new SynchronizedClass();
        ClassThreadA a = new ClassThreadA(service);
        a.setName("ThreadA");
        a.start();
        ClassThreadB b = new ClassThreadB(service);
        b.setName("ThreadB");
        b.start();
    }
}

// Class锁对类的所有对象实例起作用。
class ClassMainTest2 {
    public static void main(String[] args) {
        SynchronizedClass service1 = new SynchronizedClass();
        SynchronizedClass service2 = new SynchronizedClass();
        ClassThreadA a = new ClassThreadA(service1);
        a.setName("ThreadA-service1");
        a.start();
        ClassThreadB b = new ClassThreadB(service2);
        b.setName("ThreadB-service2");
        b.start();
    }
}

输出结果
在这里插入图片描述

同步synchronized(*.class)代码块的作用其实和synchronized static方法作用一样。
Class锁对类的所有对象实例起作用。

鳄鱼儿
关注
专栏目录
Java同步锁synchronized的最全总结
夏日清风
10-22 6040
一、并发同步问题   线程安全是Java并发编程中的重点，而造成线程安全问题的主要原因有两点，一是存在共享数据(也称临界资源)，二是存在多条线程共同操作共享数据。因此，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式就叫互斥锁。也就是说当一个共享数据被正在访问的线程加上互斥锁后，在同一个时刻，其他线程只能处于等待的状态...
Java同步锁Synchronized底层源码和原理剖析
赵广陆
05-24 779
目录1 synchronized场景回顾2 反汇编寻找锁实现原理3 synchronized虚拟机源码3.1 HotSpot源码Monitor生成3.2 HotSpot源码之Monitor竞争3.3 HotSpot源码之Monitor等待3.4 HotSpot源码之Monitor释放 1 synchronized场景回顾 目标： synchronized回顾（锁分类–>多线程） 概念 synchronized：是Java中的关键字，是一种同步锁。 Java中锁分为以下几种： 乐观锁、悲观锁(syn)
Java开发之高并发必备篇——线程安全操作之synchronized
zhaohuodian的博客
09-22 3019
上述介绍了synchronized的使用和原理，我们发现虽然synchronized锁实现了并发安全，但是它有点“重”，因为当一个线程访问同步方法或者代码块获取锁了之后，其他的线程都处于等待阻塞状态，浪费CPU的资源，并且频繁的获取和释放锁也消耗CPU的性能等等，所以以前一提到synchronized大家都说它是一个重量级锁。synchronized犹如一把锁，当一个线程访问之后就锁定访问的共享资源代码段，达到互斥的效果，从而保证了线程的安全，并且同一个线程可以获取同一把锁多次，达到可重入的效果。
synchronized(this)、synchronized(class)与synchronized(Object)的区别
热门推荐
java小酱油
12-22 5万+
在多线程开发中，我们经常看到synchronized(this)、synchronized(*.class)与synchronized(任意对象)这几种类型同步方法。
java 多线程 Synchronized方法和方法块 synchronized(this)和synchronized(object)的理解
xxyyww的专栏
08-01 2万+
<br />synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。<br />1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：<br />public synchronized void accessVal(int newVal);<br />synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得
「java」synchronized（this） 区块
qq_36098284的博客
04-15 900
该关键字的作用：当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。 synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。 用法是: synchronized(this){/*区块*/}，它的作用域是当前对象； 下面使用例子分别解释下面几句话的含义： 一、当两个并发线程访问同一个对象obj...
详细解读java同步之synchronized解析
08-26
综上，`synchronized`关键字是Java中实现线程同步的关键，通过多种优化策略提升了并发性能，并提供了不同级别的锁机制来适应不同的场景需求。理解并熟练掌握`synchronized`的使用对于编写高性能、线程安全的Java程序...
java中synchronized（同步代码块和同步方法）详解及区别
08-31
本篇文章将详细介绍`synchronized`的两种形式：同步代码块和同步方法，并分析它们的区别。 1. **同步代码块 (Synchronized Block)** 同步代码块的语法结构如下： ```java synchronized (object) { // 需要同步...
Java使用synchronized实现互斥锁功能示例
08-19
在本文中，我们将通过实例形式剖析Java使用synchronized实现互斥锁功能的简单实现方法与操作技巧。 一、synchronized关键字概述 synchronized关键字是Java语言中的一种同步机制，用于控制多个线程访问共享资源的...
synchronized(this)总结
AntonioChan's Java Technology
02-13 956
本文主要阐述以下三个问题： 1.       synchronzied作用 2.       synchronzied语法 3.       对synchronized(this)的理解   首先，解释一下synchronzied作用 Synchronzied关键字的作用一个词概括就是：线程同步。它可以用来修改对象中的方法，将对象加锁。相当于不管哪一个线程A每次运行到这个方法时,
java锁synchronized(this) 与synchronized(class) 有啥区别
最新发布
HD243608836的博客
04-01 385
synchronized(this) 与 synchronized(class) 相同处：均对代码加锁，实现互斥性。synchronized(this) 与 synchronized(class) 区别：作用域不同。
线程synchronized(this)
DUXINGRUFENG的博客
06-17 711
synchronized(this)总结 本文主要阐述以下三个问题： 1. synchronzied作用 2. synchronzied语法 3. 对synchronized(this)的理解 首先，解释一下synchronzied作用 Synchronzied关键字的作用一个词概括就是：线程同步。它可以用来修改对象中的方法，将对象加锁。相当...
synchronized(this)和synchronized(obj)
weixin_43887870的博客
02-05 2095
首先synchronized(this)和synchronized(obj)区别
synchronized(this) 与synchronized(class) 之间的区别
weixin_34248705的博客
05-19 392
  一、概念 synchronized 是 Java 中的关键字，是利用锁的机制来实现同步的。 锁机制有如下两种特性： 互斥性：即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程中的协调机制，这样在同一时间只有一个线程对需同步的代码块(复合操作)进行访问。互斥性我们也往往称为操作的原子性。 可见性：必须确保在锁被释放之前，对共享变量所做的修改，对于随后获得该锁的另一个线...
Java中Synchronized(this)和Synchronized(class)的区别
太多的虚幻
08-20 1万+
区别 Synchronized(this) 锁住该代码块的对象，等访问该对象的线程执行完，其他线程才可以执行。 Synchronized(xxx.class)  锁住该类，所有访问该类的线程，一次只有一个可以执行。 其他 A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静
synchronized(class)、synchronized(this)与synchronized(object)
蜗牛架构师
03-24 2829
JAVA中synchronized关键字能够作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。假如再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。synchronized void f() { /* body */ } 和void f(
java synchronized(syncObject) 和 synchronized(this)
weixin_30835923的博客
10-23 160
用synchronized(syncObject)看起来比较好如下： public class test_sync extends Thread { Integer x = 0; public test_sync() { } public void run() { try { Thread.sleep(1000); } catch (InterruptedExcept...
JAVA 同步函数以this为锁
wu_lai_314的专栏
03-10 5291
//仅作为学习笔记 /* 同步函数用的是this锁 函数需要被对象调用。那么函数都有一个所属对象调用，就是this 所以同步函数使用的锁是this 通过该程序进行验证 使用两个线程来卖票 一个线程在同步代码块中 一个线程在同步函数中 都在执行卖票操作 */ class Ticket implements Runnable { private int
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鳄鱼儿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值