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

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

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

参考文章：

www.cnblogs.com/baizhanshi/…


文章标签：
Java
调度
关键词：
Java线程
线程线程同步
线程Java线程同步
线程Java
Java线程同步
游客kpg7vddhfmo3k
目录
相关文章
蓝易云
|
5天前
|
安全 Java API
java如何请求接口然后终止某个线程
通过本文的介绍，您应该能够理解如何在Java中请求接口并根据返回结果终止某个线程。合理使用标志位或 `interrupt`方法可以确保线程的安全终止，而处理好网络请求中的各种异常情况，可以提高程序的稳定性和可靠性。
蓝易云
35 6
游客762btuqu5wybw666
|
18天前
|
存储 监控 小程序
Java中的线程池优化实践####
本文深入探讨了Java中线程池的工作原理，分析了常见的线程池类型及其适用场景，并通过实际案例展示了如何根据应用需求进行线程池的优化配置。文章首先介绍了线程池的基本概念和核心参数，随后详细阐述了几种常见的线程池实现（如FixedThreadPool、CachedThreadPool、ScheduledThreadPool等）的特点及使用场景。接着，通过一个电商系统订单处理的实际案例，分析了线程池参数设置不当导致的性能问题，并提出了相应的优化策略。最终，总结了线程池优化的最佳实践，旨在帮助开发者更好地利用Java线程池提升应用性能和稳定性。 ####
游客762btuqu5wybw666
46 13
aliyun0641063962-48771
|
20天前
|
缓存 Java 开发者
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱，如竞态条件、死锁和内存一致性错误，并提供了实用的避免策略。通过分析典型错误案例，本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧，从而提升并发程序的稳定性和性能。 ####
aliyun0641063962-48771
46 11
游客nmbcre4jd7shs
|
14天前
|
安全 算法 Java
Java多线程编程中的陷阱与最佳实践####
本文探讨了Java多线程编程中常见的陷阱，并介绍了如何通过最佳实践来避免这些问题。我们将从基础概念入手，逐步深入到具体的代码示例，帮助开发者更好地理解和应用多线程技术。无论是初学者还是有经验的开发者，都能从中获得有价值的见解和建议。 ####
游客nmbcre4jd7shs
33 4
mg的嘟嘟
|
14天前
|
Java 调度
Java中的多线程编程与并发控制
本文深入探讨了Java编程语言中多线程编程的基础知识和并发控制机制。文章首先介绍了多线程的基本概念，包括线程的定义、生命周期以及在Java中创建和管理线程的方法。接着，详细讲解了Java提供的同步机制，如synchronized关键字、wait()和notify()方法等，以及如何通过这些机制实现线程间的协调与通信。最后，本文还讨论了一些常见的并发问题，例如死锁、竞态条件等，并提供了相应的解决策略。
mg的嘟嘟
38 3
游客7v53mftipku2u
|
15天前
|
监控 Java 开发者
深入理解Java中的线程池实现原理及其性能优化####
本文旨在揭示Java中线程池的核心工作机制，通过剖析其背后的设计思想与实现细节，为读者提供一份详尽的线程池性能优化指南。不同于传统的技术教程，本文将采用一种互动式探索的方式，带领大家从理论到实践，逐步揭开线程池高效管理线程资源的奥秘。无论你是Java并发编程的初学者，还是寻求性能调优技巧的资深开发者，都能在本文中找到有价值的内容。 ####
游客7v53mftipku2u
31 1
Java开发者
|
20天前
|
缓存 Java 开发者
Java多线程并发编程：同步机制与实践应用
本文深入探讨Java多线程中的同步机制，分析了多线程并发带来的数据不一致等问题，详细介绍了`synchronized`关键字、`ReentrantLock`显式锁及`ReentrantReadWriteLock`读写锁的应用，结合代码示例展示了如何有效解决竞态条件，提升程序性能与稳定性。
Java开发者
73 6
最好zzz
|
18天前
|
监控 Java 数据库连接
Java线程管理：守护线程与用户线程的区分与应用
在Java多线程编程中，线程可以分为守护线程（Daemon Thread）和用户线程（User Thread）。这两种线程在行为和用途上有着明显的区别，了解它们的差异对于编写高效、稳定的并发程序至关重要。
最好zzz
26 2
潇洒洒
|
18天前
|
监控 Java 开发者
Java线程管理：守护线程与本地线程的深入剖析
在Java编程语言中，线程是程序执行的最小单元，它们可以并行执行以提高程序的效率和响应性。Java提供了两种特殊的线程类型：守护线程和本地线程。本文将深入探讨这两种线程的区别，并探讨它们在实际开发中的应用。
潇洒洒
25 1
muxiaoxi
|
20天前
|
安全 Java 开发者
Java中的多线程编程：从基础到实践
本文深入探讨了Java多线程编程的核心概念和实践技巧，旨在帮助读者理解多线程的工作原理，掌握线程的创建、管理和同步机制。通过具体示例和最佳实践，本文展示了如何在Java应用中有效地利用多线程技术，提高程序性能和响应速度。
muxiaoxi
54 1

热门文章

最新文章

  • 1
    线程状态&&Wait和sleep的区别？
  • 2
    ConcurrentDictionary线程不安全么
  • 3
    threading多线程总结
  • 4
    java中线程存活和线程执行的问题！
  • 5
    线程的优先级
  • 6
    c#多线程 Invoke方法的使用
  • 7
    object-c 多线程 加锁
  • 8
    多线程锁sync+lock使用，@Async使用
  • 9
    线程基础知识系列(二）线程的管理
  • 10
    明述java中线程(thread)的使用(1)
  • 1
    【Java开发指南 | 第三十一篇】Java 包(package)
    71
  • 2
    【Java开发指南 | 第二十九篇】Java接口
    46
  • 3
    【Java开发指南 | 第二十八篇】Java封装
    53
  • 4
    【Java开发指南 | 第二十六篇】Java多态
    40
  • 5
    【Java开发指南 | 第二十四篇】Java继承
    58
  • 6
    【Java开发指南 | 第九篇】访问实例变量和方法、继承、接口
    53
  • 7
    【Java开发指南 | 第八篇】Java变量、构造方法、创建对象
    92
  • 8
    Java Stream API详解与使用
    93
  • 9
    Java医院绩效考核系统源码B/S+avue+MySQL助力医院实现精细化管理
    80
  • 10
    《手把手教你》系列技巧篇（四十三）-java+ selenium自动化测试-处理https 安全问题或者非信任站点-上篇（详解教程）
    131

    • 相关课程

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

    • 相关电子书

    更多
  • 如何通过 Serverless 提高 Java 微服务治理效
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • 多IO线程优化版

    • 相关实验场景

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