java线程原理（AQS、condition、线程池、锁）

Java 中线程的所有知识点，并用表格展示：

知识点	描述
概述	线程是 Java 中实现并发编程的一种机制，它可以使多个任务并发地执行。
创建线程	在 Java 中，可以通过继承 Thread 类或实现 Runnable 接口的方式创建线程。
线程状态	在 Java 中，线程有多个状态，包括新建、就绪、运行、阻塞、等待、计时等待、终止等状态。
线程同步	在多线程编程中，需要使用线程同步机制来保证多个线程对共享资源的访问正确性。Java 中提供了多种线程同步机制，包括 synchronized 关键字、Lock 接口、Semaphore 类、CountDownLatch 类等。
线程通信	在多线程编程中，需要使用线程通信机制来协调多个线程之间的执行顺序。Java 中提供了多种线程通信机制，包括 wait()、notify()、notifyAll() 方法、Condition 接口、BlockingQueue 接口等。
线程池	线程池是一种用于管理线程的机制，它可以避免频繁创建和销毁线程，提高线程的复用率，提高系统的性能。Java 中提供了 Executor 框架和 ThreadPoolExecutor 类来实现线程池。
线程安全	线程安全是指在多线程环境下，对共享资源的访问不会出现问题，Java 中提供了多种线程安全的机制，包括 synchronized 关键字、AtomicXXX 类、ConcurrentHashMap 类等。
线程调试	在多线程编程中，线程调试是一种重要的技能，Java 中提供了多种线程调试工具，包括 jstack、jconsole、jvisualvm 等。
注意事项	在使用线程时，需要注意线程安全、避免死锁等问题，同时也需要注意线程优化、线程调度等问题。

ThreadPoolExecutor 的所有知识点，并用表格展示：

知识点	描述
概述	ThreadPoolExecutor 是 Java 中实现线程池的核心类，它可以管理线程池中的线程，实现线程的复用和调度。
创建	在 Java 中，可以使用 ThreadPoolExecutor 类来创建线程池，其中需要指定线程池的核心线程数、最大线程数、任务队列、拒绝策略等参数。
工作原理	ThreadPoolExecutor 工作原理是将任务提交到任务队列中，由线程池中的线程来执行，当线程池中线程数达到核心线程数时，新的任务将被放入任务队列中，当任务队列已满时，将会创建新的线程来执行任务，直到线程数达到最大线程数为止。
方法	ThreadPoolExecutor 类提供了多个方法，包括 execute() 方法、submit() 方法、shutdown() 方法、shutdownNow() 方法等。
线程池参数	在创建 ThreadPoolExecutor 时，需要指定线程池的核心线程数、最大线程数、任务队列、拒绝策略等参数，这些参数会影响线程池的工作效率和性能。
线程池状态	线程池有多个状态，包括 RUNNING、SHUTDOWN、STOP、TERMINATED 等状态，这些状态反映了线程池的当前状态和可用性。
线程池拒绝策略	当线程池中的线程数达到最大线程数并且任务队列已满时，需要使用线程池拒绝策略来处理新的任务，Java 中提供了多种拒绝策略，包括 AbortPolicy、CallerRunsPolicy、DiscardPolicy、DiscardOldestPolicy 等。
线程池优化	在使用线程池时，需要注意线程池的优化，包括调整线程池参数、避免创建过多的线程、避免任务阻塞等。
注意事项	在使用线程池时，需要注意线程安全、避免死锁等问题，同时也需要注意线程优化、线程调度等问题。

ReentrantLock 类的所有知识点，并用表格展示：

知识点	描述
概述	ReentrantLock 是一个可重入的互斥锁，具有与 synchronized 相同的基本行为和语义，但提供了更高的灵活性和扩展性。
实现原理	ReentrantLock 的实现基于 AQS（AbstractQueuedSynchronizer）框架，实现了公平锁和非公平锁两种模式。
重入性	ReentrantLock 支持重入，即同一个线程可以多次获取锁，而不会发生死锁。
锁的获取和释放	ReentrantLock 提供了 lock() 和 unlock() 方法，用于获取和释放锁。
公平锁和非公平锁	ReentrantLock 支持公平锁和非公平锁两种模式。在公平锁模式下，锁会按照线程的等待时间来分配，而在非公平锁模式下，锁会优先分配给已经在等待的线程。
条件变量	ReentrantLock 中可以通过 newCondition() 方法创建 Condition 对象，用于实现线程间的等待和唤醒。
锁的性能	ReentrantLock的性能比 synchronized 差，但在高并发、竞争激烈的情况下，ReentrantLock的性能优于synchronized。
使用场景	ReentrantLock 适用于需要更高灵活性和扩展性的场景，例如需要支持公平锁和非公平锁、需要支持多个条件等待等场景。
注意事项	在使用 ReentrantLock 时，需要手动释放锁，否则可能会导致死锁等问题。同时，在使用 Condition 对象时，也需要注意正确地使用 signal() 和 signalAll() 方法，否则可能会导致线程无法被唤醒。

Condition 类的所有知识点，并用表格展示：

知识点	描述
概述	Condition 类是 Java 中用于实现线程间等待和唤醒的一种机制，它可以让线程在等待某个条件成立时进入休眠状态，并在条件满足时被唤醒。
与 Lock 接口一起使用	Condition 类通常与 Lock 接口一起使用，用于实现更加灵活和高效的线程同步。
方法	Condition 类提供了三个方法：await()、signal() 和 signalAll()，它们分别对应 Object 类中的 wait()、notify() 和 notifyAll() 方法。
等待和唤醒	await() 方法用于让线程进入等待状态，直到接收到 signal() 或 signalAll() 方法的通知才会被唤醒。signal() 方法用于唤醒一个等待中的线程，而 signalAll() 方法则会唤醒所有等待中的线程。
多条件等待	Condition 类支持多个条件等待，可以通过多个 Condition 对象来实现。
注意事项	在使用 Condition 类时，需要注意正确地使用 await()、signal() 和 signalAll() 方法，否则可能会导致线程无法被唤醒或出现死锁等问题。同时，在使用 Condition 对象时，也需要注意正确地获取对应的锁，否则会抛出 IllegalMonitorStateException 异常。

AbstractQueuedSynchronizer 类的所有知识点，并用表格展示：

知识点	描述
概述	AbstractQueuedSynchronizer（AQS）是一个用于实现同步器的框架类，它是 ReentrantLock、Semaphore、CountDownLatch 等同步工具类的基础。
实现原理	AQS 基于一个双向队列来维护等待线程，通过状态变量来控制线程的获取和释放锁。
状态变量	AQS 中的状态变量可以是一个 int 类型的变量，也可以是一个 AtomicInteger 类型的变量，用于表示同步器的状态。
获取和释放锁	AQS 中提供了 acquire() 和 release() 方法，用于获取和释放锁。
等待队列	AQS 中使用一个双向队列来维护等待线程，等待队列中的节点是一个继承自 Node 类的内部类，表示一个等待线程。
独占模式和共享模式	AQS 支持独占模式和共享模式两种同步方式。独占模式是指只有一个线程可以获取锁，而共享模式则允许多个线程同时获取锁。
条件变量	AQS 中也支持条件变量，可以通过 ConditionObject 类来实现线程间的等待和唤醒。
自定义同步器	AQS 可以作为一个同步框架，用于实现自定义的同步器。
注意事项	在使用 AQS 时，需要注意正确地实现 acquire() 和 release() 方法，避免出现竞态条件等问题。此外，在自定义同步器时，也需要注意正确地实现 tryAcquire() 和 tryRelease() 方法，否则可能会导致同步器无法正常工作。

LockSupport 类的所有知识点，并用表格展示：

知识点	描述
概述	LockSupport 类是 Java 中用于实现线程等待和唤醒的一种机制，它可以让线程在等待某个条件成立时进入休眠状态，并在条件满足时被唤醒。
静态方法	LockSupport 类提供了一些静态方法，包括 park()、unpark()、parkNanos()、parkUntil() 等方法。
park() 方法	park() 方法用于让当前线程进入等待状态，直到接收到 unpark() 方法的通知才会被唤醒。
unpark() 方法	unpark() 方法用于唤醒一个等待中的线程，如果该线程还没有进入等待状态，则下一次进入等待状态时会立即被唤醒。
parkNanos()	和 parkUntil() 方法 parkNanos() 和 parkUntil() 方法与 park() 方法类似，但可以指定等待的时间。
注意事项	在使用 LockSupport 类时，需要注意正确地使用 park() 和 unpark() 方法，否则可能会导致线程无法被唤醒或出现死锁等问题。同时，在使用 park() 方法时，也需要注意正确地使用循环，以避免虚假唤醒等问题。

CAS 的所有知识点，并用表格展示：

知识点	描述
概述	CAS（Compare and Swap）是 Java 中一种基于原子操作实现的并发编程机制，它可以在不使用锁的情况下保证多个线程对同一变量的原子性操作。
原理	CAS 原理是基于 CPU 的 CMPXCHG 指令实现的，该指令会比较内存中的值和给定的值是否相等，如果相等则将新值写入内存中，否则不做任何操作。
实现	在 Java 中，可以使用 java.util.concurrent.atomic 包中的 AtomicXXX 类来实现 CAS 操作，其中 AtomicXXX 类提供了多个方法，如 compareAndSet()、getAndSet()、getAndIncrement() 等。
优点	CAS 的优点包括无锁、原子性、高并发等。
缺点	CAS 的缺点包括ABA 问题、自旋次数过多等。
ABA 问题	ABA 问题是指当一个变量的值从 A 变为 B，再变回 A 时，如果在这个过程中有其他线程对该变量进行了修改，那么 CAS 会误认为变量的值没有发生变化，从而出现错误。
解决ABA问题	解决 ABA 问题的方法包括使用版本号、使用 AtomicStampedReference 或 AtomicMarkableReference 等。
注意事项	在使用 CAS 时，需要注意使用合适的原子操作方式、正确处理 ABA 问题、避免自旋次数过多等问题。

CountDownLatch 的相关知识点如下表格:

知识点	说明
CountDownLatch 构造方法	CountDownLatch(long count)\ count 表示需要计数到 0 的数目。 可以是大于等于 0 的任何数量。
await() 方法	一旦 count 达到 0,await() 方法会释放所有被挂起的线程。\ await() 会导致当前线程进入阻塞状态,直到 count 变为 0。
countDown() 方法	将 count 的值减 1。减少计数器。
isOpen() 方法	如果count达到 0,则返回true,否则返回false。 可以用来检查锁是否已经打开。
同一时刻只允许一个或多个线程进入await() 方法	如果在 count 大于 0 时多次调用 await(),所有这些调用将被阻塞直到 count 变为 0。
可以传递 CountDownLatch 的引用给多个线程	多个线程可以共享同一个 CountDownLatch 对象来控制它们的执行,直到count达到 0。
释放blocked threads 的主要功能	CountDownLatch 的主要功能是能够释放在 await() 方法上被阻塞的多个线程,直到某个预期条件被满足(即 count 达到 0)。

Semaphore 类的所有知识点，并用表格展示：

知识点	描述
概述	Semaphore 类是 Java 中用于实现线程同步的一种机制，它可以限制同时访问某个资源的线程数量。
构造方法	Semaphore 类提供了多个构造方法，其中最常用的是 Semaphore(int permits) 构造方法，它用于创建一个指定初始许可证数量的 Semaphore 对象。
重要方法	Semaphore 类提供了多个重要的方法，包括 acquire()、release()、tryAcquire()、tryAcquire(long timeout, TimeUnit unit) 等。
acquire() 方法	acquire() 方法用于获取一个许可证，如果当前没有可用的许可证，则线程将阻塞直到有可用的许可证。
release() 方法	release() 方法用于释放一个许可证，将它返回给 Semaphore 对象，如果有等待的线程，则其中一个线程将被唤醒，获取该许可证并继续执行。
tryAcquire() 方法	tryAcquire() 方法尝试获取一个许可证，如果获取成功，则立即返回 true，否则返回 false。
tryAcquire(long timeout, TimeUnit unit) 方法	tryAcquire(long timeout, TimeUnit unit) 方法尝试获取一个许可证，如果在指定的时间内获取成功，则立即返回 true，否则返回 false。
注意事项	在使用 Semaphore 类时，需要注意正确地使用 acquire() 和 release() 方法，以避免出现死锁等问题。同时，也需要注意正确地设置初始许可证数量以及使用 tryAcquire() 和 tryAcquire(long timeout, TimeUnit unit) 方法时的超时时间。

ScheduledThreadPool的所有知识点的归纳和表格展示：

知识点	描述
ScheduledThreadPool	ScheduledThreadPool是Java的一个类，提供了一个线程池，可以在指定时间或延迟后执行任务。
线程池大小	ScheduledThreadPool有一个可配置的最大线程池大小，用于控制同时运行的任务数量。
任务提交	可以使用schedule方法将任务提交到ScheduledThreadPool中。该方法接受一个可调用对象（如Runnable或Callable接口的实现类）和表示何时执行任务的时间或时间间隔的参数，并返回一个ScheduledFuture对象，该对象可以用于跟踪任务的进度并在需要时检索其结果。
定时任务	ScheduledThreadPool可以使用schedule方法在指定的时间或延迟后执行任务。
循环任务	ScheduledThreadPool可以使用scheduleAtFixedRate和scheduleWithFixedDelay方法在固定的时间间隔或延迟后重复执行任务。
任务取消	ScheduledFuture对象可以用于取消尚未完成的任务。可以使用cancel方法取消任务，并在需要时指定是否应中断正在运行的任务。
关闭线程池	ScheduledThreadPool可以使用shutdown方法关闭，该方法将停止接受新任务，并等待所有任务完成后关闭线程池。
优雅关闭	ScheduledThreadPool还提供了一个更优雅的关闭方法shutdownNow，该方法将尝试立即停止所有任务并关闭线程池。但是，它不会等待所有任务完成，并且可能会导致一些任务无法完成。
异常处理	如果使用schedule方法提交的任务引发异常，则异常将被捕获并存储在关联的ScheduledFuture对象中。可以使用get方法检索结果，并在需要时处理异常。

LinkedBlockingDeque的所有知识点的归纳和表格展示：

知识点	描述
LinkedBlockingDeque	LinkedBlockingDeque是Java的一个类，是一个基于链表实现的阻塞双端队列。
队列容量	LinkedBlockingDeque可以选择指定容量，如果没有指定，则默认容量为Integer.MAX_VALUE。
阻塞式操作	LinkedBlockingDeque支持阻塞式操作，例如put、take、offer、poll等，这些操作在队列为空或满时会阻塞线程，直到有空间或元素可用。
阻塞超时	LinkedBlockingDeque的阻塞操作可以设置超时时间，如果在指定时间内未完成操作，则会返回false或null。
非阻塞式操作	LinkedBlockingDeque还支持非阻塞式操作，例如add、remove、offerFirst、pollLast等，这些操作在队列为空或满时会立即返回结果。
遍历操作	LinkedBlockingDeque提供了一些遍历队列元素的方法，例如iterator、descendingIterator、toArray等。
队列转换	LinkedBlockingDeque提供了一些转换队列的方法，例如addFirst、addLast、removeFirst、removeLast等，用于将队列转换为栈、双端队列等。
线程安全	LinkedBlockingDeque是线程安全的，它的所有操作都是原子性的，内部使用了锁和条件变量来保证线程安全性。
性能	LinkedBlockingDeque的性能通常比ArrayBlockingQueue好，因为它使用链表来实现队列，可以动态地调整大小，并且它的阻塞式操作使用了条件变量来避免忙等待。但是，由于它使用链表，因此在随机访问和遍历时可能会出现性能问题。