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

JUC高并发编程1：JUC概述

article 2024/11/14 21:02:50

1 什么是JUC

1.1 JUC简介

JUC就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5 开始出现的。

1.2 进程与线程

进程（Process）和线程（Thread）是操作系统中用于实现多任务处理的两种基本概念。它们在操作系统中扮演着不同的角色，并且有着不同的特性和用途。

1.2.1 进程（Process）

定义：

  • 进程是操作系统中资源分配的基本单位。一个进程就是一个正在执行的程序的实例，它包含了程序代码、数据、堆栈、文件描述符等资源。

特性：

  1. 独立性：每个进程都有自己独立的地址空间，一个进程的崩溃通常不会影响其他进程。
  2. 资源分配：操作系统为每个进程分配独立的内存空间、文件描述符、CPU时间等资源。
  3. 创建与销毁：进程的创建和销毁需要较多的系统资源和时间，因为涉及到资源的分配和回收。
  4. 通信：进程之间的通信通常需要使用操作系统提供的进程间通信（IPC）机制，如管道、消息队列、共享内存等。

用途：

  • 进程通常用于执行独立的任务，如运行一个独立的应用程序。

1.2.2 线程（Thread）

定义：

  • 线程是进程中的一个执行单元，是操作系统调度的基本单位。一个进程可以包含多个线程，这些线程共享进程的资源。

特性：

  1. 共享资源：线程共享其所属进程的地址空间、文件描述符、全局变量等资源。
  2. 轻量级：线程的创建和销毁比进程快得多，因为它们共享进程的资源，不需要重新分配内存等资源。
  3. 通信：线程之间的通信相对简单，因为它们共享内存，可以直接访问共享变量。
  4. 并发性：多个线程可以在同一个进程中并发执行，从而提高程序的执行效率。

用途：

  • 线程通常用于实现并发处理，如在图形用户界面（GUI）应用程序中处理用户输入和后台任务。

1.2.3 进程与线程的关系

  • 包含关系：一个进程可以包含多个线程，这些线程共享进程的资源。
  • 并发性：进程和线程都可以并发执行，但线程的并发性更强，因为它们共享资源，切换开销更小。
  • 隔离性：进程之间相互隔离，一个进程的崩溃通常不会影响其他进程；而线程之间共享资源，一个线程的错误可能会影响整个进程。

1.2.4 总结

  • 进程：独立的执行环境，资源分配的基本单位，适用于独立的任务。
  • 线程：共享进程资源的执行单元，调度的基本单位，适用于并发处理。

1.3 线程的状态

1.3.1 Java中的线程状态枚举类

在Java中，线程的状态是由Thread.State枚举类定义的。以下是Java中常见的线程状态：

public enum Thread.State {
    // 线程刚刚创建，但还没有启动
    NEW,

    // 线程正在运行或准备运行
    RUNNABLE,

    // 线程正在等待监视器锁，以便进入同步代码块或方法
    BLOCKED,

    // 线程正在等待某个条件的发生，通常是通过调用Object.wait()或Thread.join()
    WAITING,

    // 线程正在等待某个条件的发生，但有一个超时时间，通常是通过调用Object.wait(long)或Thread.sleep(long)
    TIMED_WAITING,

    // 线程已经执行完毕
    TERMINATED;
}

1.3.2 线程状态的转换

线程在生命周期中会经历不同的状态转换。以下是常见的线程状态转换图：

NEW -> RUNNABLE -> (BLOCKED | WAITING | TIMED_WAITING) -> TERMINATED
  1. NEW：线程刚刚创建，但还没有调用start()方法。
  2. RUNNABLE：线程正在运行或准备运行。
  3. BLOCKED：线程正在等待获取监视器锁，以便进入同步代码块或方法。
  4. WAITING：线程正在等待某个条件的发生，通常是通过调用Object.wait()或Thread.join()。
  5. TIMED_WAITING：线程正在等待某个条件的发生，但有一个超时时间，通常是通过调用Object.wait(long)或Thread.sleep(long)。
  6. TERMINATED：线程已经执行完毕。

1.3.3 示例代码

以下是一个简单的Java代码示例，展示了如何获取和打印线程的状态：

public class ThreadStateExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(1000); // 让线程进入TIMED_WAITING状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("线程状态: " + thread.getState()); // NEW

        thread.start();
        System.out.println("线程状态: " + thread.getState()); // RUNNABLE

        try {
            Thread.sleep(500); // 主线程等待500毫秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("线程状态: " + thread.getState()); // TIMED_WAITING

        try {
            thread.join(); // 等待线程执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("线程状态: " + thread.getState()); // TERMINATED
    }
}

1.3.4 wait/sleep的区别

wait()：

  • 是 Object 类的方法。

  • 调用时必须持有对象的监视器锁。

  • 调用后会释放锁，进入等待状态。

  • 需要其他线程调用 notify() 或 notifyAll() 来唤醒。

  • 用于线程间的协调和同步。

sleep()：

  • 是 Thread 类的方法。

  • 调用时不会释放锁。

  • 指定睡眠时间后自动唤醒。

  • 可以被中断，抛出 InterruptedException。

  • 用于延迟执行或控制线程的执行节奏

1.4 并发与并行

1.4.1 串行模式

串行模式（Serial Mode）是指在计算机系统中，任务或操作按照顺序一个接一个地执行，而不是并发执行。在这种模式下，每个任务必须在前一个任务完成后才能开始执行。串行模式通常用于确保任务的执行顺序和数据的一致性，特别是在需要严格控制执行顺序的场景中。

1.4.2 串行模式的特点

  1. 顺序执行：任务按照预定的顺序依次执行，前一个任务完成后，后一个任务才能开始。
  2. 单线程：通常在单线程环境中执行，没有并发性。
  3. 简单性：实现简单，不需要复杂的同步机制。
  4. 可靠性：由于任务顺序执行，数据一致性和可靠性较高。
  5. 性能限制：由于没有并发性，系统的整体性能可能受到限制，特别是在处理大量任务时。

1.4.3 并行模式

并行模式（Parallel Mode）是指在计算机系统中，多个任务或操作同时执行，而不是顺序执行。并行模式可以显著提高系统的处理能力和响应速度，特别是在多核处理器和分布式系统中。并行模式可以通过多线程、多进程、分布式计算等方式实现。

1.4.4 并行模式的特点

  1. 并发执行：多个任务可以同时执行，充分利用多核处理器和分布式系统的资源。
  2. 多线程/多进程：通过创建多个线程或进程来实现任务的并行执行。
  3. 复杂性：实现和维护相对复杂，需要处理线程间同步、资源竞争等问题。
  4. 性能提升：可以显著提高系统的处理能力和响应速度。
  5. 资源利用率高：在多核处理器上，并行模式可以充分利用多核资源，提高资源利用率。

1.4.5 并发

并发(concurrent)指的是多个程序可以同时运行的现象，更细化的是多进程可以同时运行或者多指令可以同时运行。

1.4.6 小结

  • 并发是指多个任务在同一时间段内交替执行，每个任务执行一段时间后，切换到另一个任务。并发强调的是任务的交替执行，而不是同时执行。
  • 并行是指多个任务在同一时刻同时执行。并行强调的是任务的同时执行，通常在多核处理器或多台计算机上实现。

1.5 管程

管程（Monitor）是一种用于实现线程同步的机制，它提供了一种高级的同步原语，使得多个线程可以安全地访问共享资源。管程通常包含一个或多个条件变量（Condition Variables），用于线程之间的等待和通知。管程的设计目标是简化并发编程中的同步问题，避免死锁和竞态条件。

1.5.1 管程的特点

  1. 互斥访问：管程确保在任何时刻只有一个线程可以进入管程，从而保证对共享资源的互斥访问。
  2. 条件变量：管程包含条件变量，用于线程之间的等待和通知。线程可以在条件变量上等待，直到其他线程发出通知。
  3. 同步机制：管程提供了一种高级的同步机制，简化了并发编程中的同步问题。
  4. 封装性：管程将共享资源和同步机制封装在一起，使得外部代码不需要关心同步细节。

1.5.2 管程的适用场景

  1. 生产者-消费者问题：多个生产者和消费者线程需要访问共享的缓冲区，通过管程可以实现线程之间的同步。
  2. 读者-写者问题：多个读者线程和写者线程需要访问共享的数据库，通过管程可以实现线程之间的同步。
  3. 互斥锁：需要对共享资源进行互斥访问的场景，通过管程可以简化同步问题。

1.6 用户线程和守护线程

在多线程编程中，线程可以分为两种类型：用户线程（User Thread）和守护线程（Daemon Thread）。它们在行为和用途上有一些显著的区别。

1.6.1 用户线程（User Thread）

定义：

  • 用户线程是应用程序中创建的普通线程，通常用于执行用户任务。

特点：

  1. 优先级高：用户线程的优先级通常较高，操作系统会优先调度用户线程。
  2. 独立性：用户线程是独立的，即使主线程结束，用户线程仍然可以继续执行。
  3. 生命周期：用户线程的生命周期不受主线程的影响，只有当所有用户线程都结束时，程序才会退出。

用途：

  • 用户线程通常用于执行用户任务，如计算、I/O操作、用户界面更新等。

1.6.2 守护线程（Daemon Thread）

定义：

  • 守护线程是一种特殊类型的线程，通常用于执行后台任务，如垃圾回收、日志记录等。

特点：

  1. 优先级低：守护线程的优先级通常较低，操作系统不会优先调度守护线程。
  2. 依赖性：守护线程依赖于用户线程，当所有用户线程都结束时，守护线程会自动终止。
  3. 生命周期：守护线程的生命周期受用户线程的影响，只有当所有用户线程都结束时，守护线程才会终止。

用途：

  • 守护线程通常用于执行后台任务，如垃圾回收、日志记录、定时任务等。

1.6.3 用户线程和守护线程的区别

  1. 优先级：

    • 用户线程：优先级较高，操作系统会优先调度用户线程。
    • 守护线程：优先级较低，操作系统不会优先调度守护线程。

  2. 独立性：

    • 用户线程：独立于主线程，即使主线程结束，用户线程仍然可以继续执行。
    • 守护线程：依赖于用户线程，当所有用户线程都结束时，守护线程会自动终止。

  3. 生命周期：

    • 用户线程：生命周期不受主线程的影响，只有当所有用户线程都结束时，程序才会退出。
    • 守护线程：生命周期受用户线程的影响，只有当所有用户线程都结束时，守护线程才会终止。

1.6.4 示例代码

以下是一个简单的示例代码，展示了如何创建用户线程和守护线程：

public class ThreadExample {
    public static void main(String[] args) {
        // 创建用户线程
        Thread userThread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("User Thread: " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 创建守护线程
        Thread daemonThread = new Thread(() -> {
            while (true) {
                System.out.println("Daemon Thread is running...");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 设置守护线程
        daemonThread.setDaemon(true);

        // 启动线程
        userThread.start();
        daemonThread.start();

        // 主线程等待用户线程结束
        try {
            userThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Main thread is finished.");
    }
}

1.6.5 总结

  • 用户线程：优先级较高，独立于主线程，生命周期不受主线程的影响，通常用于执行用户任务。
  • 守护线程：优先级较低，依赖于用户线程，生命周期受用户线程的影响，通常用于执行后台任务。

2 思维导图

在这里插入图片描述

3 参考链接

【【尚硅谷】大厂必备技术之JUC并发编程】


http://www.kler.cn/a/317030.html

相关文章：

  • C# 模拟浏览器自操作(自动化办公)
  • Android Studio 将项目打包成apk文件
  • 【mysql】使用宝塔面板在云服务器上安装MySQL数据库并实现远程连接
  • 基于标签相关性的多标签学习
  • C获取程序名称的方法
  • WPF学习之路，控件的只读、是否可以、是否可见属性控制
  • 基于flask常见trick——unicode进制编码绕过
  • JavaEE: 深入探索TCP网络编程的奇妙世界(六)
  • PCL 基于kd树快速删除点云中重叠的点
  • AWS EKS 中的负载均衡和 TLS 配置：全面指南
  • 【二分算法】模板总结
  • QT菜单之快捷菜单设计
  • 解决方案：spark数据进行加工转换后，进行数据存储的时候，发现数据行为空
  • STM32如何修改外部晶振频率和主频
  • 用递归函数实现汉诺塔游戏
  • 使用命令行 (Anaconda Prompt)
  • Spring Boot ｜ 使用 `@Scheduled`: 定时任务的实现与优化
  • MySQL和SQL的区别简单了解和分析使用以及个人总结
  • 面向对象 vs 面向过程
  • Unreal Engine 5 C++: 插件编写03 | MessageDialog
  • 线上搭子小程序：随时随地找搭子！
  • 详解Linux中cat命令
  • 软件开发详解：通过源码搭建高效的食堂采购与供应链管理平台
  • VOC2007数据集
  • Linux高级I/O：多路转接模型
  • 计算机毕业设计 校园志愿者管理系统的设计与实现 Java实战项目 附源码+文档+视频讲解