一篇完整学习JUC并发编程（包含实例源码）

**一篇完整学习JUC并发编程**

Java Util Concurrency (JUC) 是 Java 并发编程的核心包，提供了各种高级并发工具类和接口。通过掌握 JUC 的知识，我们可以更好地利用多核 CPU 的优势，提高程序的并发性和性能。

###1. 线程池线程池是 Java 中最常用的并发工具之一，它允许我们重用一组已经创建好的线程来执行任务，而不是每次都新建一个线程。这样可以避免频繁地创建和销毁线程带来的性能开销。

####1.1 ExecutorExecutor 是线程池的核心接口，它提供了 execute() 和 submit() 方法来执行任务。

java// Executor 接口示例public class MyExecutor implements Executor {
 @Override public void execute(Runnable command) {
 Thread thread = new Thread(command);
 thread.start();
 }
}

####1.2 ThreadPoolExecutorThreadPoolExecutor 是 Executor 的实现类，它提供了多种配置选项来控制线程池的行为。

java// ThreadPoolExecutor 示例public class MyThreadPoolExecutor extends ThreadPoolExecutor {
 public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
 long keepAliveTime, TimeUnit unit,
 BlockingQueue workQueue) {
 super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
 }

 @Override protected void beforeExecute(Thread t, Runnable r) {
 System.out.println("线程 " + t.getName() + " 即将执行任务");
 }

 @Override protected void afterExecute(Runnable r, Throwable t) {
 System.out.println("任务已完成");
 }
}

####1.3 使用线程池使用线程池非常简单，我们只需要创建一个 ThreadPoolExecutor 实例，然后通过 execute() 或 submit() 方法来执行任务。

java// 使用线程池示例public class MyRunnable implements Runnable {
 @Override public void run() {
 System.out.println("任务正在执行");
 }
}

public class Main {
 public static void main(String[] args) {
 ThreadPoolExecutor executor = new ThreadPoolExecutor(5,10,0L,
 TimeUnit.SECONDS, new LinkedBlockingDeque());
 executor.execute(new MyRunnable());
 }
}

###2. 锁锁是 Java 中用于同步访问共享资源的基本机制。通过使用锁，我们可以确保在多线程环境下，共享资源只被一个线程访问。

####2.1 ReentrantLockReentrantLock 是 Java 中最常用的锁实现类，它提供了多种配置选项来控制锁的行为。

java// ReentrantLock 示例public class MyReentrantLock {
 private final ReentrantLock lock = new ReentrantLock();

 public void doSomething() {
 lock.lock();
 try {
 System.out.println("正在执行任务");
 } finally {
 lock.unlock();
 }
 }
}

####2.2 synchronizedsynchronized 是 Java 中用于同步访问共享资源的关键字，它可以用来修饰方法或代码块。

java// synchronized 示例public class MySynchronized {
 public synchronized void doSomething() {
 System.out.println("正在执行任务");
 }
}

####2.3 使用锁使用锁非常简单，我们只需要创建一个 ReentrantLock 实例，然后通过 lock() 和 unlock() 方法来控制锁的行为。

java// 使用锁示例public class MyRunnable implements Runnable {
 private final ReentrantLock lock = new ReentrantLock();

 @Override public void run() {
 lock.lock();
 try {
 System.out.println("任务正在执行");
 } finally {
 lock.unlock();
 }
 }
}

###3. 原子类原子类是 Java 中用于保证多线程环境下操作的原子性的一组类。通过使用原子类，我们可以确保在多线程环境下，操作不会被中断。

####3.1 AtomicIntegerAtomicInteger 是 Java 中用于保证整型变量的原子性的一种原子类。

java// AtomicInteger 示例public class MyAtomicInteger {
 private final AtomicInteger count = new AtomicInteger(0);

 public void increment() {
 count.incrementAndGet();
 }

 public int getCount() {
 return count.get();
 }
}

####3.2 AtomicLongAtomicLong 是 Java 中用于保证长整型变量的原子性的一种原子类。

java// AtomicLong 示例public class MyAtomicLong {
 private final AtomicLong count = new AtomicLong(0);

 public void increment() {
 count.incrementAndGet();
 }

 public long getCount() {
 return count.get();
 }
}

####3.3 使用原子类使用原子类非常简单，我们只需要创建一个 AtomicInteger 或 AtomicLong 实例，然后通过相关方法来操作变量。

java// 使用原子类示例public class MyRunnable implements Runnable {
 private final AtomicInteger count = new AtomicInteger(0);

 @Override public void run() {
 for (int i =0; i < 10000; i++) {
 count.incrementAndGet();
 }
 System.out.println(count.get());
 }
}

###4. 阻塞队列阻塞队列是 Java 中用于实现生产者-消费者模式的一种数据结构。通过使用阻塞队列，我们可以确保在多线程环境下，生产者和消费者之间的数据传递不会被中断。

####4.1 LinkedBlockingQueueLinkedBlockingQueue 是 Java 中最常用的阻塞队列实现类，它提供了多种配置选项来控制队列的行为。

java// LinkedBlockingQueue 示例public class MyLinkedBlockingQueue {
 private final LinkedBlockingQueue queue = new LinkedBlockingQueue<>();

 public void put(String item) throws InterruptedException {
 queue.put(item);
 }

 public String take() throws InterruptedException {
 return queue.take();
 }
}

####4.2 ArrayBlockingQueueArrayBlockingQueue 是 Java 中用于实现固定大小的阻塞队列的一种数据结构。

java// ArrayBlockingQueue 示例public class MyArrayBlockingQueue {
 private final ArrayBlockingQueue queue = new ArrayBlockingQueue<>(10);

 public void put(String item) throws InterruptedException {
 queue.put(item);
 }

 public String take() throws InterruptedException {
 return queue.take();
 }
}

####4.3 使用阻塞队列使用阻塞队列非常简单，我们只需要创建一个 LinkedBlockingQueue 或 ArrayBlockingQueue 实例，然后通过相关方法来操作队列。

java// 使用阻塞队列示例public class MyRunnable implements Runnable {
 private final LinkedBlockingQueue queue = new LinkedBlockingQueue<>();

 @Override public void run() {
 for (int i =0; i < 10000; i++) {
 try {
 queue.put("item");
 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 }
 }
 }
}

通过掌握 JUC 的知识，我们可以更好地利用多核 CPU 的优势，提高程序的并发性和性能。