当前位置： 首页 > article >正文

深入学习Synchronized各种使用方法

article 2024/11/19 16:22:41

文章目录

  • 前言
  • 一、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.kler.cn/a/158760.html

相关文章：

  • 探索 HTML 和 CSS 实现的 3D旋转相册
  • Go语言基本类型转换
  • ubuntu显示管理器_显示导航栏
  • 大语言模型通用能力排行榜（2024年11月8日更新)
  • shell 100例
  • 深度学习笔记14-卷积神经网络2
  • springboot 整合 Spring Security 上篇
  • 在外包待了6年，技术退步太明显......
  • 【数据结构实验】树（一）构建二叉查找树(BST)
  • 了解 ignore_above 参数对 Elasticsearch 中磁盘使用的影响
  • Linux: FS: inotify
  • C语言还会存在多久
  • 数据结构基础（不带头节点的单向非循环链表）
  • NAS-DIP: Learning Deep Image Prior with Neural Architecture Search
  • 基于ssm vue的风景文化管理平台源码和论文
  • MicroPython 基于microdot框架搭建网页服务器
  • Oracle Flashback技术简介与快速入门
  • centos中mysql8忘记密码的操作步骤
  • JAVA 线程池，及7大参数，4大拒绝策略详解
  • 连接池 Druid （三） - 获取连接 getConnection
  • 【C++ protobuf中对不同消息内容进行赋值的方式】
  • Appium：iOS测试比Android测试更难？
  • Linux-hid
  • Shell数组函数：数组（二）
  • 继在统信UOS上运行.Net Core之后，保持其在后台运行，并出错自重启
  • Unity渲染Stats分析