【Java】解析synchronized中的锁对象

已于 2023-06-03 16:59:42 修改
阅读量630 收藏 2
点赞数 3
分类专栏： JavaEE初阶 文章标签： java javaee jvm 后端 开发语言
于 2023-05-24 15:33:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43243800/article/details/130847165
版权

锁对象

先看一下Java中是如何定义对象的。在Java虚拟机中，对象在内存中的结构可以划分为4部分区域：
🟢markword
🟢类型指针(_class)
🟢实例数据(instance_data)
🟢对齐填充(padding)
其中前两个在对象头中，实例数据表示类中的属性，对齐填充代表每一个类的对象占用的字节数必须是8字节的整数倍。Java中的对象都包含一个叫对象头的部分，其中markword区域主要描述了当前是哪个线程获取到了锁资源，记录的是线程对象信息，当线程释放锁资源的时候就会把线程对象信息清除掉，其他线程就可以继续获取锁资源。

常见的几种情况

我们定义两个线程分别实现自增50000次,使用不同的锁对象，看最终结果能否达到预期。
1、定义一个自增操作对象调用一个自增方法，里面要竞争的锁对象是同一个this，此时可以达到预期。

public class Demo01_Synchronized {
    // 定义自增操作的对象
    private static Counter2 counter = new Counter2();

    public static void main(String[] args) throws InterruptedException {
        // 定义两个线程，分别自增5万次
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increment();
            }
        });

        // 启动线程
        t1.start();
        t2.start();
        // 等待自增完成
        t1.join();
        t2.join();
        // 打印结果
        System.out.println("count = " + counter.count);

    }
}
class Counter2 {
    public static int  count = 0;
    // 自增方法
    public synchronized void increment () {
        count++;
    }
}

2、定义两个自增操作对象在调用同一个自增方法时，里面要竞争的this并不是同一个对象，不会产生锁竞争关系，得不到预期结果。

public class Demo04_Synchronized {
    // 定义自增操作的对象
    private static Counter4 counter = new Counter4();
    private static Counter4 counter1 = new Counter4();

    public static void main(String[] args) throws InterruptedException {
        // 定义两个线程，分别自增5万次
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter1.increment();
            }
        });

        // 启动线程
        t1.start();
        t2.start();
        // 等待自增完成
        t1.join();
        t2.join();
        // 打印结果
        System.out.println("count = " + counter.count);

    }
}
class Counter4 {
    public static int count = 0;
    // 自增方法
    public synchronized void increment () {
        count++;
    }
}

3、自定义一个对象来充当锁对象的角色,用一个自增操作对象来调用自增方法可以得到预期结果。

public class Demo05_Synchronized {
    // 定义自增操作的对象
    private static Counter5 counter = new Counter5();
    public static void main(String[] args) throws InterruptedException {
        // 定义两个线程，分别自增5万次
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increment();
            }
        });

        // 启动线程
        t1.start();
        t2.start();
        // 等待自增完成
        t1.join();
        t2.join();
        // 打印结果
        System.out.println("count = " + counter.count);

    }
}
class Counter5 {
    public static int count = 0;
    //定义一个对象来充当锁对象的角色
    Object locker = new Object();
    // 自增方法
    public void increment () {
        synchronized (locker){
            count++;
        }
    }
}

4、在3的基础上定义两个自增操作对象分别调用自增方法，不能得到预期结果，原因在于locker对象作为成员变量每次new的时候都会初始化一次，得到的locker对象不是同一个对象，不会发生锁竞争关系。

public class Demo05_Synchronized {
    // 定义自增操作的对象
    private static Counter5 counter = new Counter5();
    private static Counter5 counter1 = new Counter5();
    public static void main(String[] args) throws InterruptedException {
        // 定义两个线程，分别自增5万次
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter1.increment();
            }
        });

        // 启动线程
        t1.start();
        t2.start();
        // 等待自增完成
        t1.join();
        t2.join();
        // 打印结果
        System.out.println("count = " + counter.count);

    }
}
class Counter5 {
    public static int count = 0;
    //定义一个对象来充当锁对象的角色
    Object locker = new Object();
    // 自增方法
    public void increment () {
        synchronized (locker){
            count++;
        }
    }
}

5、在4的基础上，用static修饰locker对象，此时可以得到预期的结果。原因在于static修饰的类成员，随着类初始化的时候全局唯一，这样每new一个自增操作的对象时访问的是同一个locker，存在锁竞争关系，能得到正确结果。

public class Demo05_Synchronized {
    // 定义自增操作的对象
    private static Counter5 counter = new Counter5();
    private static Counter5 counter1 = new Counter5();
    public static void main(String[] args) throws InterruptedException {
        // 定义两个线程，分别自增5万次
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter1.increment();
            }
        });

        // 启动线程
        t1.start();
        t2.start();
        // 等待自增完成
        t1.join();
        t2.join();
        // 打印结果
        System.out.println("count = " + counter.count);

    }
}
class Counter5 {
    public static int count = 0;
    //定义一个对象来充当锁对象的角色
    private static Object locker = new Object();
    // 自增方法
    public void increment () {
        synchronized (locker){
            count++;
        }
    }
}

6、使用类对象充当锁对象也会产生锁竞争，因为类对象是全局唯一的。

public class Demo06_Synchronized {

    // 定义自增操作的对象
    private static Counter6 counter = new Counter6();
    private static Counter6 counter1 = new Counter6();

    public static void main(String[] args) throws InterruptedException {
        // 定义两个线程，分别自增5万次
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                // 调用加锁的方法
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                // 调用没有加锁的方法
                counter1.increment();
            }
        });

        // 启动线程
        t1.start();
        t2.start();
        // 等待自增完成
        t1.join();
        t2.join();
        // 打印结果
        System.out.println("count = " + counter.count);

    }
}

class Counter6 {
    public static int count = 0;

    public void increment() {
        // 使用Counter6类对象充当锁对象
        synchronized (Counter6.class) {
            // 要执行的修改逻辑
            count++;
        }
    }
//    public void increment() {
//        // 使用String类对象充当锁对象
//        synchronized (String.class) {
//            // 要执行的修改逻辑
//            count++;
//        }
//    }
}

总结

在多线程环境中，保证多个线程之间竞争的锁对象是同一个即可，锁对象可以是Java中的任何对象。需要重点要理解，synchronized 锁的是什么.？两个线程竞争同一把锁，才会产生阻塞等待；两个线程分别尝试获取两把不同的锁, 不会产生竞争。
在这里插入图片描述

继续加油~
在这里插入图片描述

java基础Synchronized关键字之对象锁
weixin_33860553的博客
11-04 485
java中Synchronized关键字之对象锁 　 当有多个线程对一个共享数据进行操作时，需要注意多线程的安全问题。 　　多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。而用的最多的就是synchronized关键字。 　　语法：Synchronized(对象锁){} 　　被synchronized关键字修饰的...
解析Java编程之Synchronized锁住的对象
08-29
Java synchronized锁住的对象解析 在Java编程中，synchronized关键字是用于同步的关键字，它可以用于锁住一个对象，以实现线程同步。但是，在使用synchronized关键字时，需要了解锁住的到底是哪个对象，否则可能...
synchronized-锁对象
Flying_Fish_roe的博客
04-07 1637
synchronized修饰方法：使用synchronized修饰方法可以锁定整个方法，使得同一时间只能有一个线程执行该方法。其他线程需要等待锁释放才能执行。synchronized修饰代码块：可以使用synchronized关键字锁定一段代码块，只有在获得锁的线程才能执行该代码块，其他线程需要等待锁释放。锁对象：synchronized关键字可以用于锁定一个对象，线程在执行synchronized代码块时，会获取该对象的锁。只有获得锁的线程才能执行该代码块，其他线程需要等待锁释放。
Synchronized锁、锁的四种状态、锁的升级（偏向锁，轻量级锁，重量级锁）
最新发布
m0_64422133的博客
11-06 1113
Synchronized【对象锁】采用互斤的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。synchronized方法和synchronized块。
synchronized是如何锁住对象的？
m0_54063422的博客
07-26 2341
synchronized是Java中的关键字，synchronized可以保证方法或者代码块在运行时，同一时刻只有一个线程可以进入到被修饰的代码块中，同时它还可以保证共享变量的内存可见性，Java中每一个对象都可以作为锁，这是synchronized实现同步的基础。修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，此时synchronized锁住的则是（）中的对象。修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，
synchronized——对象锁
你若盛开，清风自来
09-16 637
synchronized的中文意思是同步的，在Java语言的它是关键字，可以用来给对象和方法或者代码加锁，当它封锁某一块代码或方法的时候，其他线程是不能访问调用这一块代码或方法的。   示例： public static synchronized int generate(String tableName){使用Java中synchronized方法解决线程同步问题 S
Synchronized锁对象详解
Bkhole的博客
10-24 2653
sychronized
synchronized 类锁 对象锁
09-08 642
synchronized 类锁 对象锁
Java并发 synchronized锁住的内容解析
08-25
Java并发synchronized锁住的内容解析是Java并发编程中的一种重要机制，用于解决多线程并发访问同一个资源时可能出现的线程安全问题。通过使用synchronized关键字，可以锁住当前对象的当前方法，使得其他线程访问该...
Java中synchronized正确使用方法解析
08-25
例如，在使用 synchronized void addOne() 方法时，锁定的是当前对象，保护的资源是对象中的成员属性 value。 四、synchronized 的使用方法 synchronized 的使用方法可以分为两种，一种是使用 synchronized 关键字...
Java对象锁和类锁全面解析（多线程synchronize
11-22
Java对象锁和类锁是Java多线程编程中至关重要的概念，它们是通过`synchronized`关键字来实现的，用于确保代码在并发环境下的线程安全。在这个全面解析中，我们将深入探讨这两个锁机制，理解它们的工作原理以及如何在...
Java synchronized关键字使用方式及特性解析
08-25
Java中的synchronized关键字是一种实现锁的方式，它是在JVM层面实现的非公平锁。synchronized关键字可以用于实现线程同步，以下是使用synchronized的四种方式： 1. 作用在方法上，保证了访问同一个对象的同一个方法...
synchronized对象锁与类锁用法&如何用synchronized锁字符串对象，这里面的坑要注意
qq_43842093的博客
03-03 1994
我们使用synchronized通常都有这样一个误区：synchronized锁住的代码块一定是所有线程都互斥的。其实不然！首先我们明确一点，synchronized锁住的是一个对象！如果锁住的这个对象，在多个线程中相同，那么这些线程访问synchronized修饰的代码块时，总是互斥的。但是！如果锁住的这个对象，在多个线程中是不同的，那么这些线程访问synchronized修饰的代码块，是不会互斥的！
理解synchronized对象锁
aduzz62084的博客
04-18 111
深入Java虚拟机去理解： 在java虚拟机中，每个对象和类在逻辑上都是和一个监视器相关联的。 对于对象来说，相关联的监视器保护对象的实例变量。 对于类来说，监视器保护类的类变量。 （如果一个对象没有实例变量，或者一个类没有变量，相关联的监视器就什么也不监视。） 为了实现监视器的排他性监视能力，java虚拟机为每一个对象和类都关联一个锁。代表任何时候只允...
【多线程锁】synchronized对象锁与类锁用法
Dust_heart的博客
07-13 4161
本文主要介绍synchronized对象锁与类锁用法，入门级别使用
Java中synchronized实现对象锁的两种方式及原理解析
五道口
05-17 7805
简介 本文将介绍Java中两种对象锁及其实现方式。分别是同步代码块锁和方法锁。我们将解决上一篇文章《Java中线程安全和线程不安全解析和示例》中提到的线程不安全问题，看看通过synchronized的对象锁，怎样轻松解决该问题。 一.同步代码块锁 案例：通过同步代码块锁，实现两个线程对同一个全局变量count,各自执行1万次count++,验证结果是否等于2万，而不会出现小于2万的情况。 完整代码实现: public class SynchronizeCodeBlockLock implements Run
Java内部锁（synchronized）中类锁和对象锁
冷血之心的博客
08-29 5800
关于对象锁、类锁以及锁争用情况的简单介绍
synchronized加锁对象是什么、synchronized底层原理
kennyharris
12-12 259
多线程、锁、synchronized
【JAVA】关于synchornized锁住的对象
xha6666的博客
04-27 262
Java synchronized
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值