JUC高并发编程1：JUC概述

1 什么是JUC

1.1 JUC简介

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

1.2 进程与线程

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

1.2.1 进程（Process）

定义：

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

特性：

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

用途：

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

1.2.2 线程（Thread）

定义：

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

特性：

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

用途：

线程通常用于实现并发处理，如在图形用户界面（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

NEW：线程刚刚创建，但还没有调用start()方法。
RUNNABLE：线程正在运行或准备运行。
BLOCKED：线程正在等待获取监视器锁，以便进入同步代码块或方法。
WAITING：线程正在等待某个条件的发生，通常是通过调用Object.wait()或Thread.join()。
TIMED_WAITING：线程正在等待某个条件的发生，但有一个超时时间，通常是通过调用Object.wait(long)或Thread.sleep(long)。
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.4.3 并行模式

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

1.4.4 并行模式的特点

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

1.4.5 并发

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

1.4.6 小结

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

1.5 管程

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

1.5.1 管程的特点

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

1.5.2 管程的适用场景

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

1.6 用户线程和守护线程

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

1.6.1 用户线程（User Thread）

定义：

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

特点：

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

用途：

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

1.6.2 守护线程（Daemon Thread）

定义：

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

特点：

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

用途：

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

1.6.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.");
    }
}