【JUC编程】JUC 多线程基础全面解析(待更新版)
文章目录
- 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");
五、并发工具的使用场景和建议
- 线程池:适用于需要频繁创建和销毁线程的场景。
- 锁:在读多写少场景下,优先考虑
ReadWriteLock
。 - 并发集合:推荐在多线程环境下使用。
- 线程间通信:
CountDownLatch
和CyclicBarrier
适合多线程协作。
六、总结
JUC 是 Java 提供的一套强大的并发工具,它简化了多线程编程的复杂性,同时提供了高效、安全的解决方案。通过合理使用线程池、锁机制、并发集合以及线程通信工具,我们可以更高效地开发并发程序。在实际开发中,应根据具体场景选择合适的工具,以保证性能与安全性。
博客主页: 总是学不会.