【JUC编程】JUC 多线程基础全面解析(速食版，25年后更新专栏)

这篇文章就多个方面简单涉及一些内容，到2025年我会更新并发编程这个专栏。计划在过年之前更新完，都是从基础到工作中常用（以及可能涉及到）的知识点，有些内容这篇文章没有提及。
希望大家可以多多支持、关注一下！

文章目录

• • • JUC 多线程基础全面解析
    • 一、线程与并发基础
    • • 1. 什么是线程？
      • 2. 并发与并行的区别
      • 3. Java 线程的基本创建方式
    • 二、JUC 核心组件
    • • 1. 线程池
      • 2. 锁机制
      • 3. 并发集合
    • 三、线程间通信工具
    • • 1. `CountDownLatch`
      • 2. `CyclicBarrier`
      • 3. `Semaphore`
    • 四、原子操作类
    • 五、并发工具的使用场景和建议
    • 六、总结

JUC 多线程基础全面解析

Java 并发工具包（Java Util Concurrent，简称 JUC）是 Java 提供的一套强大的并发编程工具，主要用于简化多线程编程，提升并发程序的性能和可靠性。本文将从以下几个方面全面解析 JUC 的基础内容：

一、线程与并发基础

1. 什么是线程？

线程是 CPU 调度的最小单元。一个线程是一个独立的执行路径，可以与其他线程共享进程内的资源。

2. 并发与并行的区别

• 并发（Concurrency）：在同一时间间隔内处理多个任务。
• 并行（Parallelism）：在同一时刻执行多个任务。

3. Java 线程的基本创建方式

• 继承 Thread 类

  class MyThread extends Thread {
      @Override
      public void run() {
          System.out.println("Thread running");
      }
  }
  new MyThread().start();
  

• 实现 Runnable 接口

  class MyRunnable implements Runnable {
      @Override
      public void run() {
          System.out.println("Runnable running");
      }
  }
  new Thread(new MyRunnable()).start();
  

• 使用 Callable 和 Future

  import java.util.concurrent.Callable;
  import java.util.concurrent.FutureTask;
  
  Callable<Integer> task = () -> {
      return 123;
  };
  FutureTask<Integer> futureTask = new FutureTask<>(task);
  new Thread(futureTask).start();
  System.out.println(futureTask.get());
  

二、JUC 核心组件

1. 线程池

线程池是 JUC 提供的一个重要工具，用于复用线程以减少线程创建和销毁的开销。

• 线程池创建方式

  import java.util.concurrent.Executors;
  import java.util.concurrent.ExecutorService;
  
  ExecutorService pool = Executors.newFixedThreadPool(5);
  pool.execute(() -> System.out.println("Task executed"));
  pool.shutdown();
  

• 常见线程池类型

  • FixedThreadPool：固定大小的线程池。
  • CachedThreadPool：动态扩展的线程池。
  • SingleThreadExecutor：单线程池。
  • ScheduledThreadPool：支持定时任务。

2. 锁机制

JUC 提供了更高级的锁，代替传统的 synchronized。

• ReentrantLock

  import java.util.concurrent.locks.ReentrantLock;
  
  ReentrantLock lock = new ReentrantLock();
  
  lock.lock();
  try {
      System.out.println("Critical section");
  } finally {
      lock.unlock();
  }
  

• ReadWriteLock 读写锁允许多个读线程同时访问，但写线程独占。

  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
  
  rwLock.readLock().lock();
  try {
      System.out.println("Reading");
  } finally {
      rwLock.readLock().unlock();
  }
  

3. 并发集合

JUC 提供了线程安全的集合类。

• ConcurrentHashMap：高效的线程安全哈希表。
• CopyOnWriteArrayList：适用于读多写少的场景。
• BlockingQueue：支持线程间安全通信的队列。

三、线程间通信工具

1. CountDownLatch

计数器，等待多个线程完成任务。

import java.util.concurrent.CountDownLatch;

CountDownLatch latch = new CountDownLatch(3);

new Thread(() -> {
    System.out.println("Task 1");
    latch.countDown();
}).start();

latch.await();
System.out.println("All tasks completed");

2. CyclicBarrier

线程到达屏障后一起执行。

import java.util.concurrent.CyclicBarrier;

CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("Barrier reached"));

new Thread(() -> {
    System.out.println("Task 1");
    barrier.await();
}).start();

3. Semaphore

控制线程并发数。

import java.util.concurrent.Semaphore;

Semaphore semaphore = new Semaphore(2);

new Thread(() -> {
    semaphore.acquire();
    System.out.println("Task running");
    semaphore.release();
}).start();

四、原子操作类

JUC 提供了一些高效的原子操作类，避免使用锁的开销。

• AtomicInteger

  import java.util.concurrent.atomic.AtomicInteger;
  
  AtomicInteger count = new AtomicInteger(0);
  count.incrementAndGet();
  

• AtomicReference

  import java.util.concurrent.atomic.AtomicReference;
  
  AtomicReference<String> ref = new AtomicReference<>("A");
  ref.compareAndSet("A", "B");
  

五、并发工具的使用场景和建议

1. 线程池：适用于需要频繁创建和销毁线程的场景。
2. 锁：在读多写少场景下，优先考虑 ReadWriteLock。
3. 并发集合：推荐在多线程环境下使用。
4. 线程间通信：CountDownLatch 和 CyclicBarrier 适合多线程协作。

六、总结

JUC 是 Java 提供的一套强大的并发工具，它简化了多线程编程的复杂性，同时提供了高效、安全的解决方案。通过合理使用线程池、锁机制、并发集合以及线程通信工具，我们可以更高效地开发并发程序。在实际开发中，应根据具体场景选择合适的工具，以保证性能与安全性。

博客主页: 总是学不会.