AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

详解线程同步和线程互斥，Java如何实现线程同步和互斥

2024-02-22 42
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 详解线程同步和线程互斥，Java如何实现线程同步和互斥

1 Why？

首先第一个问题，为什么进行线程同步和线程互斥？

最开始我们的操作系统的作业的调度单位是进程，但是由于每个进程都单独占据一个资源，而且进程的形态转换非常的耗费系统资源。

为了系统的调度更加轻量级，能够更好的支持并发，因此引入了线程这个概念。

PS：进程和线程的关系：

  • 线程是进程的一个实体
  • 同一进程内的不同线程共享该进程的系统资源

    所以问题的答案来了，因为同一进程内的不同线程共享该进程的系统资源，这就导致了资源竞争的问题，为了能够解决这个问题，所以引入了线程互斥，就是为了能够在单位时间内只有一个线程共享该进程的系统资源。而进程同步就是让多个线程合理有序的访问该进程的系统资源。

2 What？

什么是线程同步？什么是线程互斥？

线程同步和线程互斥，类似于进程同步和进程互斥，在《操作系统》这本书中有另一个好听的名字：直接制约和间接制约

直接制约（同步关系）：

某些应用程序，为了完成某个任务而建立了两个或多个进程（源于进程间的合作）。

间接制约（互斥关系）：

多个程序并发执行时，由于共享系统资源（如CUP、I/O设备等）而导致这些并发执行的程序之间形成相互的制约

的关系。

因此，我们知道了线程同步和线程互斥的关系：

  1. 互斥是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性，访问是无序的。
  2. 同步是指在互斥的基础上，通过其它机制实现访问者对资源的有序访问。
  3. 同步其实已经实现了互斥，所以同步是一种更为复杂的互斥。
  4. 互斥是一种特殊的同步。

3 How？

Java如何实现线程同步和线程互斥？

先说简单的，Java实现线程互斥：

无线程互斥的情况：

/**
 * @desc: 没有进行互斥的情况
 * @author: YanMingXin
 * @create: 2021/12/19-18:02
 **/
public class Method0 {
    private int value = 10;
    private void reduce() {
        try {
            while (value == 0) {
                System.out.println("stop...");
                return;
            }
            System.out.println(Thread.currentThread().getName() + "：" + value);
            value--;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private void make() {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(3, 5, 3, TimeUnit.SECONDS, new LinkedBlockingDeque<>());
        for (int i = 0; i < 20; i++) {
            poolExecutor.execute(() -> {
                reduce();
            });
        }
    }
    public static void main(String[] args) {
        Method0 methodA = new Method0();
        methodA.make();
    }
}

方式一：互斥锁synchronized

/**
 * @desc: 互斥方式一
 * @author: YanMingXin
 * @create: 2021/12/19-17:48
 **/
public class MethodA {
    private int value = 10;
    private synchronized void reduce() {
        try {
            while (value == 0) {
                System.out.println("stop...");
                return;
            }
            System.out.println(Thread.currentThread().getName() + "：" + value);
            value--;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private void make() {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(3, 5, 3, TimeUnit.SECONDS, new LinkedBlockingDeque<>());
        for (int i = 0; i < 20; i++) {
            poolExecutor.execute(() -> {
                reduce();
            });
        }
    }
    public static void main(String[] args) {
        MethodA methodA = new MethodA();
        methodA.make();
    }
}

方式二：可重入互斥锁ReentrantLock

/**
 * @desc: 互斥方式二
 * @author: YanMingXin
 * @create: 2021/12/19-17:50
 **/
public class MethodB {
    private int value = 10;
    private ReentrantLock lock=new ReentrantLock();
    private void reduce(){
        lock.lock();
        try {
            while (value == 0) {
                System.out.println("stop...");
                return;
            }
            System.out.println(Thread.currentThread().getName() + "：" + value);
            value--;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    private void make() {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(3, 5, 3, TimeUnit.SECONDS, new LinkedBlockingDeque<>());
        for (int i = 0; i < 20; i++) {
            poolExecutor.execute(() -> {
                reduce();
            });
        }
    }
    public static void main(String[] args) {
        MethodB methodA = new MethodB();
        methodA.make();
    }
}

然后，Java实现线程同步：

无线程同步的情况：

/**
 * @desc: 无线程同步状态
 * @author: YanMingXin
 * @create: 2021/12/19-17:47
 **/
public class Method0 {
    private int value = 0;
    private static List list = new ArrayList<String>();
    static {
        list = Arrays.asList("1-Insert", "2-Delete", "3-Update", "4-Select");
    }
    private void reduce() {
        try {
            System.out.println(list.get(value));
            value++;
            while (value > 3) {
                System.out.println("stop...");
                return;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private void make() {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                4,
                4,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>());
        for (int i = 0; i < 4; i++) {
            poolExecutor.execute(() -> {
                reduce();
            });
        }
        poolExecutor.shutdown();
    }
    public static void main(String[] args) {
        Method0 methodA = new Method0();
        methodA.make();
    }
}

方式一：synchronized进行线程同步

/**
 * @desc: 线程同步方式一
 * @author: YanMingXin
 * @create: 2021/12/19-17:47
 **/
public class MethodA {
    private int value = 0;
    private static List list = new ArrayList<String>();
    static {
        list = Arrays.asList("1-Insert", "2-Delete", "3-Update", "4-Select");
    }
    private synchronized void reduce() {
        try {
            System.out.println(list.get(value));
            value++;
            while (value > 3) {
                System.out.println("stop...");
                return;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private void make() {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                4,
                4,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>());
        for (int i = 0; i < 4; i++) {
            poolExecutor.execute(() -> {
                reduce();
            });
        }
        poolExecutor.shutdown();
    }
    public static void main(String[] args) {
        MethodA methodA = new MethodA();
        methodA.make();
    }
}

方式二：ReentrantLock进行线程同步

/**
 * @desc: 线程同步方式二
 * @author: YanMingXin
 * @create: 2021/12/19-17:47
 **/
public class MethodA {
    private int value = 0;
    private ReentrantLock lock = new ReentrantLock();
    private static List list = new ArrayList<String>();
    static {
        list = Arrays.asList("1-Insert", "2-Delete", "3-Update", "4-Select");
    }
    private void reduce() {
        lock.lock();
        try {
            System.out.println(list.get(value));
            value++;
            while (value > 3) {
                System.out.println("stop...");
                return;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    private void make() {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                4,
                4,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>());
        for (int i = 0; i < 4; i++) {
            poolExecutor.execute(() -> {
                reduce();
            });
        }
        poolExecutor.shutdown();
    }
    public static void main(String[] args) {
        MethodA methodA = new MethodA();
        methodA.make();
    }
}

方式三：synchronized代码块

/**
 * @desc: 线程同步方式三
 * @author: YanMingXin
 * @create: 2021/12/19-17:47
 **/
public class MethodA {
    private int value = 0;
    private static List list = new ArrayList<String>();
    static {
        list = Arrays.asList("1-Insert", "2-Delete", "3-Update", "4-Select");
    }
    private void reduce() {
        synchronized (this) {
            try {
                System.out.println(list.get(value));
                value++;
                while (value > 3) {
                    System.out.println("stop...");
                    return;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    private void make() {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                4,
                4,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>());
        for (int i = 0; i < 4; i++) {
            poolExecutor.execute(() -> {
                reduce();
            });
        }
        poolExecutor.shutdown();
    }
    public static void main(String[] args) {
        MethodA methodA = new MethodA();
        methodA.make();
    }
}

参考文章：

https://www.cnblogs.com/baizhanshi/p/6844356.html

文章标签：
Java
调度
关键词：
Java线程
线程线程同步
线程Java线程同步
线程Java
Java线程同步
海风极客
目录
相关文章
大数据文摘
|
1天前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类：`Producer`（生产者）、`Consumer`（消费者）、`Resource`（公共资源）和`TestMain`（测试类）。通过`synchronized`和`wait/notify`机制控制线程同步，但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`，解决了多次生产和消费的问题，但仍可能因`notify()`随机唤醒线程而导致死锁。因此，引入了`notifyAll()`来唤醒所有等待线程，但这会带来性能问题。
大数据文摘
20 1
Java—多线程实现生产消费者
2G冲浪词条
|
3天前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中，`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性，通过锁机制确保线程安全；`volatile` 仅保证可见性和有序性，不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结：`volatile` 确保不同线程对共享变量操作的可见性，使一个线程修改后，其他线程能立即看到最新值。
2G冲浪词条
21 7
大数据文摘
|
3天前
|
消息中间件 缓存 安全
Java多线程是什么
Java多线程简介：本文介绍了Java中常见的线程池类型，包括`newCachedThreadPool`（适用于短期异步任务）、`newFixedThreadPool`（适用于固定数量的长期任务）、`newScheduledThreadPool`（支持定时和周期性任务）以及`newSingleThreadExecutor`（保证任务顺序执行）。同时，文章还讲解了Java中的锁机制，如`synchronized`关键字、CAS操作及其实现方式，并详细描述了可重入锁`ReentrantLock`和读写锁`ReadWriteLock`的工作原理与应用场景。
大数据文摘
23 7
栈江湖
|
3天前
|
安全 Java 编译器
深入理解Java中synchronized三种使用方式：助您写出线程安全的代码
`synchronized` 是 Java 中的关键字，用于实现线程同步，确保多个线程互斥访问共享资源。它通过内置的监视器锁机制，防止多个线程同时执行被 `synchronized` 修饰的方法或代码块。`synchronized` 可以修饰非静态方法、静态方法和代码块，分别锁定实例对象、类对象或指定的对象。其底层原理基于 JVM 的指令和对象的监视器，JDK 1.6 后引入了偏向锁、轻量级锁等优化措施，提高了性能。
栈江湖
18 3
栈江湖
|
3天前
|
存储 安全 Java
Java多线程编程秘籍：各种方案一网打尽，不要错过！
Java 中实现多线程的方式主要有四种：继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点，适用于不同的场景。继承 Thread 类最简单，实现 Runnable 接口更灵活，Callable 接口支持返回结果，线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外，还介绍了多线程相关的常见面试问题及答案，涵盖线程概念、线程安全、线程池等知识点。
栈江湖
38 2
蓝易云
|
11天前
|
安全 Java API
java如何请求接口然后终止某个线程
通过本文的介绍，您应该能够理解如何在Java中请求接口并根据返回结果终止某个线程。合理使用标志位或 `interrupt`方法可以确保线程的安全终止，而处理好网络请求中的各种异常情况，可以提高程序的稳定性和可靠性。
蓝易云
43 6
游客nmbcre4jd7shs
|
20天前
|
安全 算法 Java
Java多线程编程中的陷阱与最佳实践####
本文探讨了Java多线程编程中常见的陷阱，并介绍了如何通过最佳实践来避免这些问题。我们将从基础概念入手，逐步深入到具体的代码示例，帮助开发者更好地理解和应用多线程技术。无论是初学者还是有经验的开发者，都能从中获得有价值的见解和建议。 ####
游客nmbcre4jd7shs
35 4
mg的嘟嘟
|
20天前
|
Java 调度
Java中的多线程编程与并发控制
本文深入探讨了Java编程语言中多线程编程的基础知识和并发控制机制。文章首先介绍了多线程的基本概念，包括线程的定义、生命周期以及在Java中创建和管理线程的方法。接着，详细讲解了Java提供的同步机制，如synchronized关键字、wait()和notify()方法等，以及如何通过这些机制实现线程间的协调与通信。最后，本文还讨论了一些常见的并发问题，例如死锁、竞态条件等，并提供了相应的解决策略。
mg的嘟嘟
43 3
游客7v53mftipku2u
|
21天前
|
监控 Java 开发者
深入理解Java中的线程池实现原理及其性能优化####
本文旨在揭示Java中线程池的核心工作机制，通过剖析其背后的设计思想与实现细节，为读者提供一份详尽的线程池性能优化指南。不同于传统的技术教程，本文将采用一种互动式探索的方式，带领大家从理论到实践，逐步揭开线程池高效管理线程资源的奥秘。无论你是Java并发编程的初学者，还是寻求性能调优技巧的资深开发者，都能在本文中找到有价值的内容。 ####
游客7v53mftipku2u
39 1
最好zzz
|
24天前
|
监控 Java 数据库连接
Java线程管理：守护线程与用户线程的区分与应用
在Java多线程编程中，线程可以分为守护线程（Daemon Thread）和用户线程（User Thread）。这两种线程在行为和用途上有着明显的区别，了解它们的差异对于编写高效、稳定的并发程序至关重要。
最好zzz
29 2

热门文章

最新文章

  • 1
    Java volatile关键字：你真的懂了吗？
  • 2
    java小工具util系列2：字符串工具
  • 3
    Java爬虫：数据采集的强大工具
  • 4
    Java中的异常处理：从基础到高级
  • 5
    深入理解Java异常处理机制
  • 6
    Liunx部署java项目Tomcat、Redis、Mysql教程
  • 7
    Java爬虫：深入解析商品详情的利器
  • 8
    java实现从HDFS上下载文件及文件夹的功能，以流形式输出，便于用户自定义保存任何路径下
  • 9
    Java 异常处理：机制、策略与最佳实践
  • 10
    Java 中的正则表达式
  • 1
    【JaveEE】——多线程中使用顺序表，队列，哈希表
    7
  • 2
    【JavaEE】——多线程常用类
    9
  • 3
    【JavaEE“多线程进阶”】——各种“锁”大总结
    7
  • 4
    【JavaEE】——线程池大总结
    8
  • 5
    【JavaEE】——单例模式引起的多线程安全问题：“饿汉/懒汉”模式，及解决思路和方法（面试高频）
    7
  • 6
    【JavaEE】——线程“饿死问题” wait && notify（面试高频）
    9
  • 7
    【JavaEE】——线程的安全问题和解决方式
    7
  • 8
    【JavaEE】——多线程（join阻塞，计算，引用，状态）
    8
  • 9
    【JavaEE】线程创建和终止，Thread类方法，变量捕获（7000字长文）
    9
  • 10
    【JavaEE】多线程编程引入——认识Thread类
    7

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    DataWorks售前咨询