Java多线程学习

简要介绍

当涉及到并发编程时，Java提供了丰富的多线程支持。以下是一些与Java多线程相关的重要知识点：

1. 线程与进程：线程是程序执行的最小单位，而进程是正在执行的程序的实例。每个Java程序都至少有一个主线程，它是程序的入口点，但可以创建额外的线程来执行并发任务。

2. Thread类与Runnable接口：Java中的线程通过Thread类来表示，可以通过继承Thread类或实现Runnable接口来创建线程。实现Runnable接口更为常见，因为它避免了单继承的限制，并能更好地支持代码的模块化和复用。

3. 线程生命周期：线程的生命周期包括新建状态、就绪状态、运行状态、阻塞状态和终止状态。可以通过调用start()方法启动线程，使其进入就绪状态，并在合适的时机由Java虚拟机调度执行。

4. 线程同步与互斥：在多线程环境中，如果多个线程同时访问共享资源，可能会引发数据竞争和不确定的结果。为了确保线程安全，可以使用synchronized关键字、Lock对象、volatile关键字等来实现线程同步和互斥，保证共享资源的正确访问。

5. 线程通信：线程之间可以通过等待/通知机制进行通信，常用的机制有wait()、notify()和notifyAll()方法。wait()方法使线程等待，释放锁资源，而notify()和notifyAll()方法则用于唤醒等待中的线程。

6. 线程安全的集合类：Java提供了一些线程安全的集合类，如ConcurrentHashMap、CopyOnWriteArrayList等，它们在多线程环境中提供了安全的操作。

7. 线程池：线程池是一种重用线程的机制，它可以管理一组线程，避免线程频繁创建和销毁的开销。通过使用线程池，可以提高程序的性能和资源利用率，同时控制线程的数量和执行顺序。

8. Callable和Future：除了Runnable接口，Java还提供了Callable接口，它可以返回一个结果并抛出异常。Callable任务提交给Executor后，可以通过Future对象来获取计算结果。

9. 同步工具类：Java提供了一些同步工具类，如CountDownLatch、CyclicBarrier、Semaphore等，用于在多线程协作和同步时提供更高级的功能。

10. 并发包：Java的并发包（java.util.concurrent）提供了丰富的并发编程工具和类，包括线程池、同步器、原子变量、并发队列等，可用于开发高效的并发程序。

在编写多线程程序时，需要注意线程安全、避免死锁、合理使用锁、控制线程的创建和销毁等，以确保程序的正确性和性能。此外，了解Java并发包的使用和原理，能够充分利用Java多线程的优势，编写高效可靠的并发程序。

程序模块与结构

Executor和Thread

Executor和Thread是Java并发编程中两个不同的概念，它们具有以下区别：

1. 功能和使用：Executor是一个接口，用于执行任务，它将任务的提交和执行进行了解耦，使得任务的执行可以由不同的执行策略和调度方式来管理。通过使用Executor，可以将任务的提交和执行进行分离，提高了代码的可维护性和可扩展性。而Thread是一个类，用于创建和操作线程，它提供了对线程的基本操作和控制。Thread用于直接创建和管理线程，可以进行线程的启动、中断、等待等操作。

2. 线程管理：Executor接口的实现类通常是线程池，它可以管理和复用线程，以提高任务执行的效率和资源利用率。通过线程池，可以预先创建一组线程，并按需分配这些线程来执行任务。而Thread类是直接操作线程的，每个Thread实例代表一个独立的线程，每次需要执行任务时都要创建一个新的线程。因此，使用线程池可以避免频繁地创建和销毁线程，减少线程创建的开销和资源消耗。

3. 任务调度：Executor提供了对任务的调度和执行的管理，可以按照特定的调度策略执行任务，如立即执行、延迟执行、周期性执行等。Executor接口的子接口ScheduledExecutorService专门用于支持定时任务的调度和执行。而Thread类并没有内建的任务调度功能，它通常用于直接执行某个具体的任务，而不涉及任务的调度和管理。

总结而言，Executor和Thread在功能和使用上有所区别。Executor用于任务的提交和执行管理，通过线程池实现线程的复用和任务调度。而Thread类用于创建和操作线程，直接执行具体的任务。Executor更加灵活和高级，适用于任务管理和调度的场景，而Thread类更加底层和直接，适用于对线程进行精细控制的场景。

线程池与Thread

线程池中的线程都是基于 Thread 类实现的。线程池内部通过创建和管理 Thread 对象来执行任务。

线程池在初始化时会创建一定数量的 Thread 对象，这些线程对象被称为核心线程。核心线程会一直存活，即使没有任务执行，以保持线程池的活跃状态。当有任务提交到线程池时，核心线程会立即执行任务。

如果提交的任务数量超过了核心线程数，而又没有超过线程池的最大线程数，线程池会创建额外的线程来执行任务，这些额外的线程被称为非核心线程。非核心线程在任务执行完毕后会被保留一段时间，以备后续的任务使用。如果在保留时间内没有新任务提交，非核心线程会被回收，以节省资源。

需要注意的是，线程池中的线程是由线程池自身创建和管理的，而不是直接由应用程序代码创建。应用程序只需要将任务提交给线程池，由线程池来分配和执行任务。

总结而言，线程池中的线程都是基于 Thread 类实现的，线程池内部创建和管理这些线程，以执行提交的任务。线程池通过核心线程和非核心线程的管理，可以提供灵活、高效的线程调度和任务执行机制。

Thread类

• Java中的线程可以继承Thread类或实现Runnable接口创建线程。

• Thread类继承了Runnable接口，同时运行的target也是Runnable的实现对象，并调用run()函数。

Runnable

• 实现Runnable更为常见，因为它避免了单继承的限制，能更好的支持代码的模块化和复用

Callable

• 与Runnable的区别在于可以返回值

Executor接口

简介

Executor接口是Java并发编程中的一个基本接口，它定义了执行任务的标准方式。Executor接口本身并没有提供线程管理或调度的功能，但它的实现类可以提供以下功能：

1. 执行任务：Executor接口的主要功能是执行任务。通过调用execute(Runnable command)方法，可以将任务提交给Executor执行。任务可以是实现了Runnable接口的对象，也可以是实现了Callable接口的对象。

2. 线程管理：Executor的实现类可以管理线程的创建、启动和销毁。它可以负责创建新线程来执行任务，并在任务完成后销毁线程，以避免线程的重复创建和销毁过程。

3. 线程池：Executor接口的常见实现类是ExecutorService接口及其实现类ThreadPoolExecutor。线程池是一种重用线程的机制，它通过维护一组线程来执行多个任务，以提高程序的性能和资源利用率。线程池管理着一定数量的线程，并根据任务的到达和完成情况，动态地调整线程的数量。

4. 任务调度：一些Executor的实现类，如ScheduledExecutorService，提供了任务调度的功能。它可以安排任务在指定的延迟时间后执行，或者按固定的时间间隔周期性地执行任务。

5. 任务控制：ExecutorService接口提供了一些方法来控制任务的执行。例如，submit()方法可以提交一个任务并返回一个Future对象，用于获取任务的执行结果或取消任务。shutdown()方法用于优雅地关闭ExecutorService，等待已提交的任务执行完成。

综上所述，Executor接口及其实现类提供了任务执行、线程管理、线程池、任务调度和任务控制等功能，为Java并发编程提供了方便和灵活性。

Executor接口只实现execute()函数：

public interface Executor {
​
    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

Executors类

简介

Executors是Java标准库中的一个实用工具类，位于java.util.concurrent包下。它提供了一些静态工厂方法，用于创建各种类型的线程池和相关的执行器对象。

Executors类主要用于创建线程池对象，简化了线程池的创建过程，提供了一些预定义的线程池配置。它提供了以下几种常见的线程池创建方法：

1. newFixedThreadPool(int nThreads)：创建一个固定大小的线程池，该线程池中最多同时执行指定数量的线程任务。

2. newCachedThreadPool()：创建一个可根据任务数量自动调整线程数量的线程池。线程池中的线程数量会根据任务的到达情况动态地增加或减少。

3. newSingleThreadExecutor()：创建一个只有单个线程的线程池，该线程池中的任务按顺序执行，保证任务的顺序性。

4. newScheduledThreadPool(int corePoolSize)：创建一个定时执行任务的线程池，可以安排任务在指定的延迟时间后执行，或按固定的时间间隔周期性地执行任务。

这些工厂方法返回了实现了ExecutorService接口的线程池对象，可以通过该对象来执行任务、管理线程池以及控制任务的执行。

Executors类还提供了其他一些方法，用于创建特定配置的线程池或执行器对象。例如，newWorkStealingPool()方法创建一个工作窃取线程池，newSingleThreadScheduledExecutor()方法创建一个单线程的定时执行任务的执行器等。

总结起来，Executors是Java中提供的一个工具类，用于创建各种类型的线程池和执行器对象，简化了线程池的创建过程，提供了一些预定义的线程池配置。它是并发编程中的常用工具之一，用于管理和执行任务的线程池。

ExecutorService接口

ExecutorService是Java并发编程中的一个接口，它是Executor接口的子接口，提供了更高级的任务管理功能。

ExecutorService接口定义了一组用于管理和控制任务执行的方法，包括提交任务、管理任务的生命周期、控制任务的执行和获取任务执行结果等。通过使用ExecutorService，可以更方便地管理和调度线程池中的任务。

以下是一些ExecutorService接口的常用方法：

1. submit(Runnable task)：提交一个Runnable任务给线程池执行，并返回一个Future对象，用于获取任务的执行结果或取消任务。

2. submit(Callable<T> task)：提交一个Callable任务给线程池执行，并返回一个Future对象，用于获取任务的执行结果或取消任务。

3. shutdown()：优雅地关闭ExecutorService，不再接受新的任务提交，但会等待已提交的任务执行完成。

4. shutdownNow()：立即关闭ExecutorService，尝试中断正在执行的任务，并返回尚未执行的任务列表。

5. awaitTermination(long timeout, TimeUnit unit)：等待ExecutorService中所有任务完成的时间，超过指定时间后返回结果。

6. isShutdown()：判断ExecutorService是否已经关闭。

7. isTerminated()：判断ExecutorService中的所有任务是否已经完成。

ExecutorService接口的实现类通常是ThreadPoolExecutor，它提供了一个线程池的实现，通过管理和复用线程来执行任务。

通过使用ExecutorService，我们可以将任务提交给线程池执行，并使用Future对象获取任务的执行结果。同时，我们可以通过shutdown()方法来优雅地关闭线程池，等待已提交的任务执行完成。

总结起来，ExecutorService接口提供了更高级的任务管理功能，可以方便地提交任务、管理任务生命周期、控制任务执行和获取任务执行结果。它是并发编程中的一个重要接口，常用于多线程任务的调度和管理。

ScheduledExecutorService接口

ScheduledExecutorService是Java并发编程中的一个接口，它是ExecutorService接口的子接口，提供了对定时任务的支持。

ScheduledExecutorService扩展了ExecutorService的功能，提供了一组用于安排和执行延迟任务或定期任务的方法。它可以在指定的延迟时间后执行任务，也可以按固定的时间间隔周期性地执行任务。

以下是ScheduledExecutorService接口的一些常用方法：

1. schedule(Runnable command, long delay, TimeUnit unit)：安排在指定的延迟时间后执行任务。

2. schedule(Callable<V> callable, long delay, TimeUnit unit)：安排在指定的延迟时间后执行Callable任务，并返回一个ScheduledFuture对象，用于获取任务的执行结果。

3. scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)：安排按固定的时间间隔周期性地执行任务。任务的第一次执行会在初始延迟时间后开始，之后每次执行会在前一次任务完成后的固定时间间隔之后开始。

4. scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)：安排按固定的延迟时间间隔周期性地执行任务。任务的第一次执行会在初始延迟时间后开始，之后每次执行会在前一次任务完成后的固定延迟时间之后开始。

ScheduledExecutorService的实现类通常是ScheduledThreadPoolExecutor，它是ThreadPoolExecutor的子类，提供了定时任务的支持。

通过使用ScheduledExecutorService，我们可以安排和执行延迟任务或定期任务。它可以替代传统的Timer类，提供了更灵活和可靠的定时任务调度。

总结而言，ScheduledExecutorService是Java中用于安排和执行定时任务的接口。它提供了一组方法，可用于在指定的延迟时间后执行任务或按固定的时间间隔周期性地执行任务。通过使用ScheduledExecutorService，可以实现灵活、可靠的定时任务调度。

ThreadPoolExecutor类

ThreadPoolExecutor是Java并发编程中的一个实现了抽象类AbstractExecutorService，其继承了ExecutorService接口，ThreadPoolExecutor是线程池实现类，用于管理和执行线程池中的任务。

ThreadPoolExecutor提供了对线程池的灵活控制，可以根据需求调整线程池的大小、线程的创建和销毁策略，并提供了一些可配置的参数来控制线程池的行为。

以下是ThreadPoolExecutor的一些主要参数和功能：

1. corePoolSize：线程池的核心线程数量，表示线程池中保持活动状态的线程数，即使它们处于空闲状态。默认情况下，核心线程会一直存在，除非调用了allowCoreThreadTimeOut(true)方法来允许核心线程超时销毁。

2. maximumPoolSize：线程池的最大线程数量，表示线程池中允许的最大线程数。当任务量超过核心线程数并且工作队列已满时，线程池会创建新的线程，直到达到最大线程数。

3. workQueue：工作队列，用于存储待执行的任务。ThreadPoolExecutor提供了多种队列实现供选择，如LinkedBlockingQueue、ArrayBlockingQueue等。

4. threadFactory：线程工厂，用于创建新线程。可以通过自定义线程工厂来指定线程的名称、优先级等。

5. rejectedExecutionHandler：拒绝策略，当任务无法执行时的处理策略。可以根据需求选择不同的拒绝策略，如抛出异常、丢弃任务、调用调用者线程执行等。

通过合理配置上述参数，可以根据应用的需求创建不同类型的线程池。例如，使用corePoolSize和maximumPoolSize控制线程的数量，workQueue控制任务的排队策略，threadFactory设置线程的属性，rejectedExecutionHandler处理任务拒绝的情况。

ThreadPoolExecutor还提供了一些方法，用于获取线程池的状态、获取已完成的任务数、设置线程池的参数等。

综上所述，ThreadPoolExecutor是Java中用于管理和执行线程池中任务的实现类。通过合理配置其参数，可以创建具有灵活控制能力的线程池，用于处理并发任务。

Future接口

Future是Java并发编程中的一个接口，用于表示异步计算的结果。它提供了一种在任务执行完成之前等待并获取任务执行结果的方式。

Future接口定义了一些方法，可以用于查询任务的执行状态、获取任务的执行结果、取消任务的执行等操作。通过Future对象，可以提交任务并获取任务的执行结果，以便在需要的时候进行处理或进一步操作。

以下是Future接口的一些常用方法：

1. boolean cancel(boolean mayInterruptIfRunning)：取消任务的执行。如果任务还没有开始执行，则尝试取消任务。如果任务已经开始执行，则根据mayInterruptIfRunning参数来决定是否中断执行任务的线程。

2. boolean isCancelled()：判断任务是否被取消。

3. boolean isDone()：判断任务是否已经完成，无论是正常完成、被取消还是由于异常结束。

4. V get()：获取任务的执行结果。如果任务已经完成，该方法会立即返回结果。如果任务还未完成，该方法会阻塞当前线程，直到任务执行完成并返回结果。

5. V get(long timeout, TimeUnit unit)：在指定的时间范围内获取任务的执行结果。如果任务在指定的时间内完成，该方法会立即返回结果。如果任务未在指定的时间内完成，则会抛出TimeoutException异常。

Future接口的实现类通常是FutureTask，它实现了RunnableFuture接口，同时也是Runnable和Future的子接口。FutureTask可以用于包装一个Callable或Runnable任务，使其具有异步执行和获取结果的能力。

通过使用Future，可以提交任务并获取任务的执行结果。在执行任务的过程中，可以通过isDone()方法判断任务是否完成，通过get()方法获取任务的结果。如果需要取消任务的执行，可以调用cancel()方法。

总结而言，Future接口提供了一种异步计算结果的机制，可以提交任务并获取任务的执行结果。它提供了一些方法用于查询任务的状态和获取结果，以便在任务执行完成之前进行等待和处理。

接口结构：

总结

在Java并发编程中，下面是ExecutorService、ThreadPoolExecutor、ScheduledExecutorService和Future之间的关系和使用方法：

1. ExecutorService是一个接口，它继承了Executor接口并扩展了一些更高级的任务管理功能。它定义了提交任务、管理任务生命周期、控制任务执行和获取任务执行结果等方法。我们可以使用ExecutorService来创建和管理线程池，以执行异步任务。

2. ThreadPoolExecutor是ExecutorService接口的一个实现类，它是一个线程池的具体实现。它通过管理和复用线程来执行任务，可以根据需求配置核心线程数、最大线程数、工作队列等参数，提供了更灵活的线程池管理。

3. ScheduledExecutorService是ExecutorService接口的一个子接口，它扩展了线程池的功能，提供了定时任务的支持。通过ScheduledExecutorService，我们可以安排和执行延迟任务或定期任务，可以按指定的延迟时间或时间间隔来执行任务。

4. Future是一个接口，用于表示异步计算的结果。它提供了一种在任务执行完成之前等待并获取任务执行结果的方式。我们可以使用Future对象来提交任务，并使用get()方法获取任务的执行结果，或者使用cancel()方法取消任务的执行。