深入学习Synchronized各种使用方法

news2024/11/27 11:53:51

文章目录

  • 前言
  • 一、synchronized关键字通用在下面四个地方：
    • 1.1synchronized修饰实例方法
    • 1.2synchronized修饰静态方法：
    • 1.3synchronized修饰实例方法的代码块
    • 1.4synchronized修饰静态方法的代码块
    • 2.读入数据
  • 二.Sychronized关键特性
    • 2.1互斥
    • 2.2 刷新内存
    • 2.3可重入
  • 三.同步互斥访问
    • 3.1同步互斥访问
    • 3.2Java中实现同步互斥访问的方法
    • 3.3Java中为什么要提供两种同步器（synchronized 和 Lock）
  • 总结

前言

提示：这里可以添加本文要记录的大概内容：
在Java当中synchronized通常是用来标记一个方法或者代码块。在Java当中被synchronized标记的代码或者方法在同一个时刻只能够有一个线程执行被synchronized修饰的方法或者代码块。因此被synchronized修饰的方法或者代码块不会出现数据竞争的情况，也就是说被synchronized修饰的代码块是并发安全的。

提示：以下是本篇文章正文内容，下面案例可供参考

一、synchronized关键字通用在下面四个地方：

1.1synchronized修饰实例方法

public class SynchronizedExample {

    // 实例变量
    private int count = 0;

    // 同步实例方法
    public synchronized void increment() {
        // 在多线程环境中，只有一个线程能够进入这个方法
        count++;
    }

    // 非同步方法
    public void nonSynchronizedMethod() {
        // 这个方法没有使用 synchronized 关键字，多个线程可以同时访问
    }

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();

        // 创建多个线程，同时访问同一个实例的 synchronized 方法
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example.increment();
                System.out.println("Thread 1 - Count: " + example.getCount());
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example.increment();
                System.out.println("Thread 2 - Count: " + example.getCount());
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();
    }

    // 获取 count 的方法
    public int getCount() {
        return count;
    }
}

increment 方法使用 synchronized 关键字修饰，确保在同一时间内只有一个线程可以进入该方法，防止多线程并发访问导致数据不一致。
nonSynchronizedMethod 方法没有使用 synchronized 关键字，因此多个线程可以同时访问，可能导致竞态条件（race condition）和数据不一致。
main 方法中创建了两个线程，分别调用 increment 方法来递增 count 变量。
getCount 方法用于获取 count 的值。

1.2synchronized修饰静态方法：

当 synchronized 修饰静态方法时，它锁定的是整个类，而不是实例。这意味着在同一时间内只有一个线程能够访问该静态方法，无论创建了多少个类实例。以下是一个使用 synchronized 修饰静态方法的简单示例：

public class SynchronizedStaticExample {

    // 静态变量
    private static int count = 0;

    // 静态同步方法
    public static synchronized void increment() {
        // 在多线程环境中，只有一个线程能够进入这个静态方法
        count++;
    }

    // 非同步方法
    public void nonSynchronizedMethod() {
        // 这个方法没有使用 synchronized 关键字，多个线程可以同时访问
    }

    public static void main(String[] args) {
        SynchronizedStaticExample example1 = new SynchronizedStaticExample();
        SynchronizedStaticExample example2 = new SynchronizedStaticExample();

        // 创建多个线程，同时访问同一个静态方法
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example1.increment();
                System.out.println("Thread 1 - Count: " + example1.getCount());
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example2.increment();
                System.out.println("Thread 2 - Count: " + example2.getCount());
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();
    }

    // 获取 count 的方法
    public int getCount() {
        return count;
    }
}

increment 方法使用 synchronized 关键字修饰，确保在同一时间内只有一个线程可以进入该静态方法。
nonSynchronizedMethod 方法没有使用 synchronized 关键字，因此多个线程可以同时访问，可能导致竞态条件（race condition）和数据不一致。
main 方法中创建了两个类实例，但由于 increment 方法是静态的，它们共享同一个静态方法，因此在同一时间内只有一个线程能够访问。
getCount 方法用于获取静态变量 count 的值。

1.3synchronized修饰实例方法的代码块

当 synchronized 修饰实例方法时，它锁定的是对象实例，确保在同一时间内只有一个线程能够访问该方法。如果有多个实例，每个实例都有独立的锁。以下是一个使用 synchronized 修饰实例方法的简单示例：

public class SynchronizedInstanceExample {

    // 实例变量
    private int count = 0;

    // 同步实例方法
    public synchronized void increment() {
        // 在多线程环境中，只有持有当前对象实例锁的线程能够进入这个方法
        count++;
    }

    // 非同步方法
    public void nonSynchronizedMethod() {
        // 这个方法没有使用 synchronized 关键字，多个线程可以同时访问
    }

    public static void main(String[] args) {
        SynchronizedInstanceExample example1 = new SynchronizedInstanceExample();
        SynchronizedInstanceExample example2 = new SynchronizedInstanceExample();

        // 创建多个线程，同时访问同一个实例方法
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example1.increment();
                System.out.println("Thread 1 - Count: " + example1.getCount());
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example2.increment();
                System.out.println("Thread 2 - Count: " + example2.getCount());
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();
    }

    // 获取 count 的方法
    public int getCount() {
        return count;
    }
}

increment 方法使用 synchronized 关键字修饰，确保在同一时间内只有持有当前对象实例锁的线程能够进入该方法。
nonSynchronizedMethod 方法没有使用 synchronized 关键字，因此多个线程可以同时访问，可能导致竞态条件（race condition）和数据不一致。
main 方法中创建了两个类实例，每个实例都有独立的锁，因此它们的 increment 方法互不影响。
getCount 方法用于获取实例变量 count 的值

1.4synchronized修饰静态方法的代码块

当 synchronized 修饰静态方法时，它锁定的是类的 Class 对象，确保在同一时间内只有一个线程能够访问该静态方法。以下是一个使用 synchronized 修饰静态方法的简单示例

public class SynchronizedStaticExample {

    // 静态变量
    private static int count = 0;

    // 静态同步方法
    public static synchronized void increment() {
        // 在多线程环境中，只有一个线程能够进入这个静态方法
        count++;
    }

    // 非同步方法
    public void nonSynchronizedMethod() {
        // 这个方法没有使用 synchronized 关键字，多个线程可以同时访问
    }

    public static void main(String[] args) {
        SynchronizedStaticExample example1 = new SynchronizedStaticExample();
        SynchronizedStaticExample example2 = new SynchronizedStaticExample();

        // 创建多个线程，同时访问同一个静态方法
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                SynchronizedStaticExample.increment();
                System.out.println("Thread 1 - Count: " + SynchronizedStaticExample.getCount());
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                SynchronizedStaticExample.increment();
                System.out.println("Thread 2 - Count: " + SynchronizedStaticExample.getCount());
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();
    }

    // 获取 count 的方法
    public static int getCount() {
        return count;
    }
}

increment 方法使用 synchronized 关键字修饰，确保在同一时间内只有一个线程能够进入该静态方法。
nonSynchronizedMethod 方法没有使用 synchronized 关键字，因此多个线程可以同时访问，可能导致竞态条件（race condition）和数据不一致。
main 方法中创建了两个类实例，但由于 increment 方法是静态的，它们共享同一个静态方法，因此在同一时间内只有一个线程能够访问。
getCount 方法用于获取静态变量 count 的值。

2.读入数据

代码如下（示例）：

data = pd.read_csv(
    'https://labfile.oss.aliyuncs.com/courses/1283/adult.data.csv')
print(data.head())

该处使用的url网络请求的数据。

二.Sychronized关键特性

2.1互斥

synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待.
进入 synchronized 修饰的代码块, 相当于 加锁
退出 synchronized 修饰的代码块, 相当于 解锁

2.2 刷新内存

synchronized 的工作过程:

  1. 获得互斥锁
  2. 从主内存拷贝变量的最新副本到工作的内存
  3. 执行代码
  4. 将更改后的共享变量的值刷新到主内存
  5. 释放互斥锁

2.3可重入

看到的这个例子很形象
在 Java 中，synchronized 关键字具有可重入性，这意味着如果一个线程已经获得了某个对象的锁，那么它可以再次请求该对象的锁而不会被阻塞。可重入性使得同一个线程在执行一个方法（或代码块）时可以再次进入同步锁定的代码区域，而不会被自己已经持有的锁所阻塞。

这种机制是为了防止由于递归调用或者方法内部调用其他同步方法而导致的死锁。如果不支持可重入性，那么在同一线程中多次调用同步方法，就会因为持有同一个锁而产生死锁。
在这里插入图片描述

public class ReentrantExample {

    public static void main(String[] args) {
        ReentrantExample example = new ReentrantExample();
        example.outerMethod();
    }

    public synchronized void outerMethod() {
        System.out.println("Outer Method");
        innerMethod();
    }

    public synchronized void innerMethod() {
        System.out.println("Inner Method");
    }
}

三.同步互斥访问

3.1同步互斥访问

在多线程编程中，通常会有多个线程同时访问一个资源的情况，同步互斥访问就是在同一时间只能有一个线程对同一资源进行访问。

3.2Java中实现同步互斥访问的方法

同步互斥访问的解决办法是设计一个同步器，对多个线程同时访问同一个共享、可变资源的情况，这个资源我们称之其为临界资源；这种资源可能是： 对象、变量、文件等
同步器采用的方案都是序列化访问临界资源。即在同一时刻，只能有一个线程访问临 界资源。
共享：资源可以由多个线程同时访问。
可变：资源可以在其生命周期内被修改。
Java中目前有 synchronized 和 Lock （ReentrantLock）。

3.3Java中为什么要提供两种同步器（synchronized 和 Lock）

synchronized在1.5版本时的状况：这是因为在jdk1.5版本的时候，jdk官方就提供出了 synchronized 锁，但是在1.5版本的时候，synchronized 锁的加锁方式只有一个，就是通过内部对象Monitor(监视器锁)实现，基于进入与退出Monitor对象实现方法与代码块同步，监视器锁的实现依赖底层操作系统的Mutex lock（互斥锁）实现，它是一个重量级锁性能较低，也就是比较消耗性能。
Lock锁的出现：由于 synchronized 锁的性能不大好，加的锁都是重要级别的锁，涉及到线程之间的状态切换，要从用户态切换到内核态，所以就有一个人设计了Lock锁，在当时，Lock锁的性能要比 synchronized 好很多。
synchronized锁的优化：后来jdk官方就对synchronized锁进行了优化，成了现在这个样子，我感觉真的基本和Lock差不多了。

总结

好了，今天的blog就到此为止，期待大佬们的三连和评论

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1286965.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Clion自定义管理和配置软件构建过程的工具(代替CMake)构建程序

Clion自定义管理和配置软件构建过程的工具(代替CMake)构建程序

在公司由于需要x86环境和其他arm环境&#xff0c;同时需要使用公司自定义的mine_x86或者mine_orin对代码进行编译。 编译命令如下mine_x86 build -Dlocal1 -j8,为使用Clion对程序进行调试&#xff0c;需要对程序进行设置。方便调试代码时能够断点查看变量。尝试了很多次&#…
阅读更多...
python高级练习题库实验1（B）部分

python高级练习题库实验1（B）部分

文章目录 题目1代码实验结果题目2代码实验结果题目3代码实验结果题目4代码实验结果题目5代码实验结果题目总结题目1 打包糖果小游戏，用户输入糖果品牌与个数，还有一个盒子里面可以装多少个糖果，输出一些打印信息，如下图所示： 代码 print("Packaging lollies into…
阅读更多...
基于springboot + vue大学生竞赛管理系统

基于springboot + vue大学生竞赛管理系统

qq&#xff08;2829419543&#xff09;获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;springboot 前端&#xff1a;采用vue技术开发 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xf…
阅读更多...
详解十大经典排序算法（五）：归并排序（Merge Sort）

详解十大经典排序算法（五）：归并排序（Merge Sort）

算法原理 归并排序的核心思想是将一个大的数组分割成多个小的子数组&#xff0c;然后分别对这些子数组进行排序&#xff0c;最后将排序后的子数组合并起来&#xff0c;得到一个有序的大数组。 算法描述 归并排序&#xff08;Merge Sort&#xff09;是一种经典的排序算法&#x…
阅读更多...
二百一十二、Flume——Flume实时采集Linux中的目录文件写入到HDFS中（亲测、附截图）

二百一十二、Flume——Flume实时采集Linux中的目录文件写入到HDFS中（亲测、附截图）

一、目的 在实现Flume实时采集Linux中的Hive日志写入到HDFS后&#xff0c;再做一个测试&#xff0c;用Flume实时采集Linux中的目录文件&#xff0c;即使用 Flume 监听Linux整个目录的文件&#xff0c;并上传至 HDFS中 二、前期准备 &#xff08;一&#xff09;安装好Hadoop、…
阅读更多...
Linux使用root用户安装完MySQL软件后,配置MySQL这个普通用户登录

Linux使用root用户安装完MySQL软件后,配置MySQL这个普通用户登录

在 Linux 系统中&#xff0c;当您使用 root 用户安装 MySQL 后&#xff0c;系统会自动创建一个名为 mysql 的系统用户。这个 mysql 用户主要用于管理 MySQL 服务的运行&#xff0c;通常是没有登录系统的权限的。如果您希望使这个 mysql 用户能够登录到系统&#xff0c;您需要设…
阅读更多...
JAVAEE初阶相关内容第十八弹--网络原理之TCP_IP【续集】

JAVAEE初阶相关内容第十八弹--网络原理之TCP_IP【续集】

写在前 上一篇博客的重点内容主要讲了关于传输层的TCP协议、UDP协议。 点击跳转上一篇博客 重点介绍了协议的特点、协议端格式、需要重点理解并掌握TCP的工作机制&#xff08;十条&#xff09;。 TCP与UDP对比&#xff1f; TCP用于可靠传输的情况&#xff0c;应用于文件传输&am…
阅读更多...
超完整的mysql安装配置方法（包含idea和navicat连接mysql,并实现建表）

超完整的mysql安装配置方法（包含idea和navicat连接mysql,并实现建表）

mysql安装配置方法 1、下载mysql2、解压到指定的安装目录3、配置初始化文件my.ini4、配置用户变量和系统变量5、初始化mysql6、安装mysql服务并启动修改密码7、使用idea连接mysql8、使用Navicat可视化工具连接mysql&#xff0c;并实现新建数据库&#xff0c;新建表 1、下载mysq…
阅读更多...
【数据结构与算法篇】八种排序 (C++实现)

【数据结构与算法篇】八种排序 (C++实现)

多种排序算法的Cpp实现 一. 排序的概念及其运用排序的概念 二. 一图速览常见排序三. 排序的C实现1> 直接插入排序2> 希尔排序希尔排序代码实现(希尔所实现)希尔排序代码实现(优化版) 3> 选择排序选择排序的代码实现(同时选出最大和最小的元素) 4> 堆排序堆排序的代…
阅读更多...
CSS面经（未完待续）

CSS面经（未完待续）

1. CSS选择器及其优先级 !important > 行内样式 > id选择器 > 类/伪类/属性选择器 > 标签/伪元素选择器 > 子/后台选择器 > *通配符 2. 重排和重绘是什么&#xff1f;浏览器的渲染机制是什么&#xff1f; 重排(回流)&#xff1a;当增加或删除dom节点&…
阅读更多...
面试就是这么简单，offer拿到手软（三）—— 常见中间件框架面试题，es，redis，dubbo，zookeeper kafka 等

面试就是这么简单，offer拿到手软（三）—— 常见中间件框架面试题，es，redis，dubbo，zookeeper kafka 等

面试就是这么简单&#xff0c;offer拿到手软&#xff08;一&#xff09;—— 常见非技术问题回答思路 面试就是这么简单&#xff0c;offer拿到手软&#xff08;二&#xff09;—— 常见65道非技术面试问题 面试就是这么简单&#xff0c;offer拿到手软&#xff08;三&#xff…
阅读更多...
DAPP开发【09】NFT交易市场开发（hardhat测试）

DAPP开发【09】NFT交易市场开发（hardhat测试）

测试文件下新建market.js文件 扁平化&#xff0c;将所有依赖放在tmp.sol&#xff0c;可以去给他人使用 npx hardhat flatten > tmp.sol 测试文件 const {expect} require(chai); const {ethers} require(hardhat);describe(Market,async function(){//定义三个合约&a…
阅读更多...
long转int类型转换问题

long转int类型转换问题

在业务代码中排序时需要根据日期排序&#xff0c;写了如下代码 sorted((o1, o2) -> {String str1 null;String str2 null;try {Field field getField(fieldMap, configBO.getCodeName());str1 String.valueOf(field.get(o1));str2 String.valueOf(field.get(o2));} ca…
阅读更多...
kubectl获取命名空间下所有configmap集合的方法

kubectl获取命名空间下所有configmap集合的方法

前言&#xff1a; 获取单个configmap并忽略特定字段的操作可参照&#xff1a;kubectl获取ConfigMap导出YAML时如何忽略某些字段。 要获取命名空间下所有ConfigMap并忽略特定字段&#xff0c;你可以使用kubectl命令与例如yq这样的工具结合使用来忽略或删除不需要的字段。以下是…
阅读更多...
分布式ID服务实践

分布式ID服务实践

背景 分布式场景下需要一个全局 ID 来标识唯一性&#xff0c;比如在单数据库时通过表唯一主键即可实现唯一 ID&#xff0c;分库分表时就需要全局唯一 ID。 业务对唯一 ID 的要求如下&#xff1a; 全局唯一性 不能出现重复的 ID 号&#xff0c;既然是唯一标识&#xff0c;这…
阅读更多...
CGAL的周期三角剖分（相关信息较少）

CGAL的周期三角剖分（相关信息较少）

CGAL的周期二维三角剖分类旨在表示二维平面上的一组点的三角剖分。该三角剖分形成其计算空间的分区。它是一个单纯复体&#xff0c;即它包含任何k-单纯形的所有关联j-单纯形&#xff08;j<k&#xff09;&#xff0c;并且两个k-单纯形要么不重叠&#xff0c;要么共享一个公共…
阅读更多...
数据结构与算法-D2D3线性表之顺序表

数据结构与算法-D2D3线性表之顺序表

线性表&#xff1a;包含若干数据元素的一个线性序列&#xff0c;特征如下&#xff1a; 1&#xff09;对非空表&#xff0c;a0是表头&#xff0c;无前驱&#xff1b; 2&#xff09;an-1是表尾&#xff0c;无后继&#xff1b; 3&#xff09;其他元素仅且仅有一个前驱&#xff0c;…
阅读更多...
Day02 Liunx高级程序设计2-文件IO

Day02 Liunx高级程序设计2-文件IO

系统调用 概念 是操作系统提供给用户使其可以操作内核提供服务的一组函数接口 用户态和内核态 其中 ring 0 权限最高&#xff0c;可以使用所有 CPU 指令&#xff0c; ring 3 权限最低&#xff0c;仅能使用 常规 CPU 指令&#xff0c;这个级别的权限不能使用访问硬件资…
阅读更多...
解决 vite 中 import.meta.globEager is not function 的问题

解决 vite 中 import.meta.globEager is not function 的问题

本人正在重构两年前搭建到一半的博客网站&#xff0c;相关依赖都很陈旧&#xff0c;用到了 npm-check-updates 检测项目可升级依赖&#xff1a; 升级完成后解决完依赖发现控制台报错 import.meta.globEager is not function解决方案&#xff1a; vite版本降至4.3.0 亲测有效&…
阅读更多...
Shell数组函数：数组（二）

Shell数组函数：数组（二）

关联数组 注意&#xff1a;先声明关联数组 一、定义关联数组 方法一 #一次赋一值 #数组名[索引]变量值 [rootlocalhost ~]# declare -A ass_array1 [rootlocalhost ~]# ass_array1[index1]pear [rootlocalhost ~]# ass_array1[index2]apple [rootlocalhost ~]# ass_array1[ind…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023