【Java多线程】（拓展1） Java Util Concurrent (JUC)

已于 2024-10-30 10:30:36 修改
阅读量760 收藏 18
点赞数 21
CC 4.0 BY-SA版权
分类专栏： Java多线程 文章标签： java 开发语言
于 2024-10-30 10:28:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/A1924/article/details/143358305

好的，接下来我们将逐部分深入讲解 Java Util Concurrent (JUC) 的内容。我们将从 JUC 概述 开始，逐步深入到具体的类和用法。

1. JUC 概述

1.1 JUC 的背景与目的

Java Util Concurrent（JUC）是 Java 5 引入的一个并发编程框架。随着多核处理器的普及，单一线程的性能已无法满足现代应用程序的需求。JUC 旨在简化多线程编程，提高程序的并发性能，使开发人员能够更容易地实现高效的并发应用。

1.2 JUC 与传统同步机制的比较

在 JUC 出现之前，Java 的多线程主要依赖于 synchronized 关键字和 wait/notify 方法。虽然这些机制可以保证线程安全，但在高并发场景中，会造成以下问题：

  • 性能瓶颈：锁竞争会导致线程阻塞，从而降低系统性能。
  • 复杂性：手动管理线程的生命周期和同步状态容易导致错误。

JUC 提供了更高级的工具，如线程池、并发集合和同步工具类，帮助开发者高效地处理并发问题。

1.3 JUC 的设计理念

JUC 的设计理念包括：

  • 减少锁的竞争：通过使用分段锁、非阻塞算法等方式，降低锁的竞争。
  • 提高并发度：通过使用线程池、无锁数据结构等方式，提升并发能力。
  • 简化多线程编程：提供高层次的 API，使得多线程编程更加简单和直观。

2. 线程池

2.1 Executor Framework

Executor Framework 提供了用于管理线程的工具，可以通过它更方便地创建和管理线程。

Executor 接口

Executor 接口定义了一个执行任务的单一方法：

void execute(Runnable command);
ExecutorService 接口

ExecutorService 是 Executor 的一个子接口，提供了更丰富的方法来管理和控制线程。

void shutdown();
List<Runnable> shutdownNow();
ScheduledExecutorService

ScheduledExecutorService 是 ExecutorService 的一个子接口，提供定时和周期性任务的执行功能。

ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);

2.2 线程池的创建与管理

可以通过 Executors 工具类创建不同类型的线程池。

示例：创建固定大小的线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
示例：创建缓存线程池
ExecutorService executorService = Executors.newCachedThreadPool();
示例：创建定时任务线程池
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);

2.3 线程池的最佳实践

  • 线程池的大小设置：一般来说，线程池的大小应设置为 CPU 核心数的 1.5 到 2 倍，具体情况可根据任务的性质进行调整。
  • 任务提交与管理：使用 submit() 方法提交任务，可以返回 Future 对象以获取任务执行的结果。
示例：使用线程池提交任务
ExecutorService executorService = Executors.newFixedThreadPool(5);
Future<Integer> future = executorService.submit(() -> {
    // 执行一些计算任务
    return 42;
});

try {
    Integer result = future.get(); // 获取任务执行结果
    System.out.println("Task result: " + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
} finally {
    executorService.shutdown(); // 关闭线程池
}

3. 并发集合

3.1 ConcurrentHashMap

ConcurrentHashMap 是线程安全的哈希表，它使用分段锁机制来提高并发性能。

特点
  • 支持高并发读写操作。
  • 不会在写入操作时锁定整个表，允许多个线程同时访问。
示例：使用 ConcurrentHashMap
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("key1", 1);
map.put("key2", 2);

// 使用 lambda 表达式遍历
map.forEach(1, (key, value) -> {
    System.out.println(key + ": " + value);
});

3.2 CopyOnWriteArrayList

CopyOnWriteArrayList 是一个线程安全的 List，适合读多写少的场景。

特点
  • 每次写操作都会复制一份底层数组，保证读操作的安全。
  • 写操作成本较高，但读操作性能优越。
示例：使用 CopyOnWriteArrayList
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("item1");
list.add("item2");

// 迭代元素
for (String item : list) {
    System.out.println(item);
}

3.3 BlockingQueue

BlockingQueue 是用于实现生产者-消费者模式的阻塞队列，可以控制线程之间的协作。

常见实现
  • ArrayBlockingQueue：基于数组的有界阻塞队列。
  • LinkedBlockingQueue：基于链表的可选界限阻塞队列。
示例：使用 BlockingQueue
BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);

// 生产者
Runnable producer = () -> {
    try {
        for (int i = 0; i < 10; i++) {
            queue.put(i); // 阻塞直到队列可用
            System.out.println("Produced: " + i);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
};

// 消费者
Runnable consumer = () -> {
    try {
        for (int i = 0; i < 10; i++) {
            Integer value = queue.take(); // 阻塞直到队列中有元素
            System.out.println("Consumed: " + value);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
};

// 启动线程
new Thread(producer).start();
new Thread(consumer).start();

3.4 ConcurrentSkipListMap 和 ConcurrentSkipListSet

  • ConcurrentSkipListMap 和 ConcurrentSkipListSet 是线程安全的有序集合，支持高效的并发访问和排序操作。

4. 同步工具类

4.1 CountDownLatch

CountDownLatch 用于在一个或多个线程中等待其他线程的完成。

使用示例
CountDownLatch latch = new CountDownLatch(3);

// 创建线程
for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        try {
            Thread.sleep(1000); // 模拟工作
            System.out.println("Task completed");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            latch.countDown(); // 计数减一
        }
    }).start();
}

// 主线程等待
try {
    latch.await(); // 等待计数为零
    System.out.println("All tasks completed");
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

4.2 CyclicBarrier

CyclicBarrier 使多个线程在某个公共点上同步，当所有线程都到达这个点时，继续执行。

使用示例
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("All threads reached the barrier, proceeding...");
});

// 创建线程
for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        try {
            System.out.println(Thread.currentThread().getName() + " arrived at the barrier");
            barrier.await(); // 等待其他线程到达
        } catch (InterruptedException | BrokenBarrierException e) {
            Thread.currentThread().interrupt();
        }
    }).start();
}

4.3 Semaphore

Semaphore 用于控制对某个资源的访问数量，可以限制同时访问某个资源的线程数量。

使用示例
Semaphore semaphore = new Semaphore(2); // 允许 2 个线程同时访问

Runnable task = () -> {
    try {
        semaphore.acquire(); // 获取许可
        System.out.println(Thread.currentThread().getName() + " acquired a permit");
        Thread.sleep(1000); // 模拟工作
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        semaphore.release(); // 释放许可
        System.out.println(Thread.currentThread().getName() + " released a permit");
    }
};

// 启动线程
for (int i = 0; i < 5; i++) {
    new Thread(task).start();
}

4.4 Exchanger

Exchanger 允许两个线程在一个点交换数据，常

用于实现双向通信。

使用示例
Exchanger<String> exchanger = new Exchanger<>();

Runnable thread1 = () -> {
    try {
        String result = exchanger.exchange("Thread 1 Data");
        System.out.println("Thread 1 received: " + result);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
};

Runnable thread2 = () -> {
    try {
        String result = exchanger.exchange("Thread 2 Data");
        System.out.println("Thread 2 received: " + result);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
};

// 启动线程
new Thread(thread1).start();
new Thread(thread2).start();

5. 原子变量

5.1 Atomic 包介绍

Atomic 包提供了一系列的原子类，用于在多线程环境中实现安全的变量更新。主要包括：

  • AtomicInteger
  • AtomicLong
  • AtomicReference

5.2 原子操作的使用

原子操作使用 CAS（Compare-And-Swap）机制，在执行更新时避免了传统锁的开销。

示例：使用 AtomicInteger
AtomicInteger atomicInt = new AtomicInteger(0);

// 多个线程并发更新
Runnable task = () -> {
    for (int i = 0; i < 1000; i++) {
        atomicInt.incrementAndGet(); // 原子增加
    }
};

// 启动多个线程
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
t1.start();
t2.start();

try {
    t1.join();
    t2.join();
    System.out.println("Final value: " + atomicInt.get());
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

6. 读写锁

6.1 ReentrantReadWriteLock

ReentrantReadWriteLock 允许多个线程同时读，但写操作是互斥的，适合读多写少的场景。

使用示例
ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
ReadWriteLock readWriteLock = rwLock.readLock();
ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();

Runnable readTask = () -> {
    readWriteLock.lock();
    try {
        // 读取操作
        System.out.println(Thread.currentThread().getName() + " is reading");
    } finally {
        readWriteLock.unlock();
    }
};

Runnable writeTask = () -> {
    writeLock.lock();
    try {
        // 写入操作
        System.out.println(Thread.currentThread().getName() + " is writing");
    } finally {
        writeLock.unlock();
    }
};

// 启动线程
new Thread(readTask).start();
new Thread(writeTask).start();

7. 线程安全的设计模式

7.1 单例模式的实现

单例模式可以通过多种方式实现线程安全的实例创建，常见方法包括懒汉式和饿汉式。

懒汉式单例（双重检查锁定）
public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

7.2 生产者-消费者模式

使用 JUC 实现生产者-消费者模型，可以利用 BlockingQueue 进行任务的协调。

示例：生产者-消费者模式
BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5);

Runnable producer = () -> {
    try {
        for (int i = 0; i < 10; i++) {
            queue.put(i);
            System.out.println("Produced: " + i);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
};

Runnable consumer = () -> {
    try {
        for (int i = 0; i < 10; i++) {
            Integer value = queue.take();
            System.out.println("Consumed: " + value);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
};

// 启动线程
new Thread(producer).start();
new Thread(consumer).start();

7.3 观察者模式

可以使用 java.util.concurrent 提供的工具类实现线程安全的观察者模式。

8. 并发调试与性能优化

8.1 常见的并发问题

  • 死锁：多个线程在等待彼此释放资源时，导致程序无法继续执行。
  • 活锁：线程之间相互干扰，导致程序一直处于活动状态，但无法完成工作。
  • 饥饿：某些线程因资源竞争而无法获得足够的资源。

8.2 JUC 性能优化

  • 使用无锁数据结构，如 ConcurrentHashMap 和 CopyOnWriteArrayList。
  • 减少锁的持有时间，尽量缩小同步代码块的范围。

8.3 使用工具进行调试

  • Java VisualVM：用于监控 Java 应用程序的性能。
  • JConsole：用于监控 Java 应用程序的内存和线程使用情况。

9. JUC 的最佳实践

9.1 代码规范

  • 在多线程代码中，确保使用恰当的同步机制。
  • 保持代码简洁，避免复杂的同步逻辑。

9.2 使用文档与示例

  • 在使用 JUC 组件时，查看官方文档和示例，以了解最佳用法。

9.3 避免常见错误

  • 避免在锁持有期间调用外部方法，以减少死锁风险。

10. 实践项目

10.1 实现一个简单的并发任务调度器

  • 设计一个支持并发执行和调度的任务管理器。

10.2 使用 JUC 解决实际业务问题

  • 利用 JUC 的特性解决实际业务场景中的并发问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天呐少爷

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值