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

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

2023-01-08 321
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 详解线程同步和线程互斥，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
目录
相关文章
凉凉心.
|
2月前
|
JSON 网络协议 安全
【Java】（10）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
189 1
凉凉心.
|
2月前
|
JSON 网络协议 安全
【Java基础】（1）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
213 1
小白学大数据
|
3月前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
小白学大数据
235 1
Java 数据库 Spring
163 0
蓝易云
|
3月前
|
算法 Java
Java多线程编程：实现线程间数据共享机制
以上就是Java中几种主要处理多线程序列化资源以及协调各自独立运行但需相互配合以完成任务threads 的技术手段与策略。正确应用上述技术将大大增强你程序稳定性与效率同时也降低bug出现率因此深刻理解每项技术背后理论至关重要.
蓝易云
266 16
艾伦~耶格尔
|
4月前
|
缓存 并行计算 安全
关于Java多线程详解
本文深入讲解Java多线程编程，涵盖基础概念、线程创建与管理、同步机制、并发工具类、线程池、线程安全集合、实战案例及常见问题解决方案，助你掌握高性能并发编程技巧，应对多线程开发中的挑战。
艾伦~耶格尔
251 0
小白学大数据
|
4月前
|
数据采集 存储 前端开发
Java爬虫性能优化：多线程抓取JSP动态数据实践
Java爬虫性能优化：多线程抓取JSP动态数据实践
小白学大数据
170 0
欲揽西江月
|
5月前
|
Java API 调度
从阻塞到畅通：Java虚拟线程开启并发新纪元
从阻塞到畅通：Java虚拟线程开启并发新纪元
欲揽西江月
369 83
AI小云
|
5月前
|
安全 算法 Java
Java 多线程：线程安全与同步控制的深度解析
本文介绍了 Java 多线程开发的关键技术，涵盖线程的创建与启动、线程安全问题及其解决方案，包括 synchronized 关键字、原子类和线程间通信机制。通过示例代码讲解了多线程编程中的常见问题与优化方法，帮助开发者提升程序性能与稳定性。
AI小云
225 0
欲揽西江月
|
5月前
|
存储 Java 调度
Java虚拟线程：轻量级并发的革命性突破
Java虚拟线程：轻量级并发的革命性突破
欲揽西江月
345 83