Java多线程系列——JDK并发包

Java并发���程是Java开发中不可或缺的一部分，它允许开发者编写能够同时执行多个任务的应用程序，提高了程序的执行效率和响应速度。自从Java 5开始，java.util.concurrent包成为了并发编程的核心，引入了多种并发工具类，使得并发程序的编写变得更加简单和高效。本文将深入探讨这个包中的各种并发工具及其用途。

Executor框架

Executor框架是java.util.concurrent包的基石，提供了管理线程池的机制，允许开发者分离任务的提交与任务的执行过程。

• Executor接口：定义了一个执行提交任务的简单接口，主要方法为execute(Runnable command)。
• ExecutorService接口：是更完善的Executor，提供了生命周期管理的方法，比如shutdown()和submit()，后者可以提交Callable任务并返回Future。
• ScheduledExecutorService接口：扩展了ExecutorService，支持定时及周期性任务执行。
• ThreadPoolExecutor和ScheduledThreadPoolExecutor类：这两个类是上述接口的具体实现，提供了灵活的线程池管理策略。

  示例 

  import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class ExecutorExample {    public static void main(String[] args) {        // 创建一个固定大小的线程池        ExecutorService executor = Executors.newFixedThreadPool(2);        // 提交任务给线程池执行        executor.submit(() -> {            System.out.println("Task 1 executed by " + Thread.currentThread().getName());        });        executor.submit(() -> {            System.out.println("Task 2 executed by " + Thread.currentThread().getName());        });        // 关闭线程池        executor.shutdown();    }}

   

  同步器

  java.util.concurrent包提供了多种同步器，帮助开发者控制并发访问和修改共享资源。

  • Semaphore（信号量）：用于控制同时访问某个特定资源的操作数量，通过协调各个线程以保证合理的使用公共资源。
  • CountDownLatch：允许一个或多个线程等待其他线程完成操作。
  • CyclicBarrier：允许一组线程相互等待，直到所有线程都到达某个公共屏障点。
  • Phaser：提供了更灵活的回合制同步，是CyclicBarrier的通用版本，支持动态地增减参与者。
  • Exchanger：允许两个线程在汇合点交换数据，用于线程间的数据交换。

    示例（使用CountDownLatch）： 

    import java.util.concurrent.CountDownLatch;public class CountDownLatchExample {    public static void main(String[] args) throws InterruptedException {        CountDownLatch latch = new CountDownLatch(2);        new Thread(() -> {            System.out.println("Task 1 started.");            // 模拟任务执行            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                Thread.currentThread().interrupt();            }            System.out.println("Task 1 finished.");            latch.countDown();        }).start();        new Thread(() -> {            System.out.println("Task 2 started.");            // 模拟任务执行            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                Thread.currentThread().interrupt();            }            System.out.println("Task 2 finished.");            latch.countDown();        }).start();        // 等待两个任务都执行完毕        latch.await();        System.out.println("All tasks finished.");    }}

     

    锁

    在java.util.concurrent.locks包中，提供了比synchronized关键字更高级的锁机制。

    • Lock接口：比synchronized更灵活的锁机制，允许尝试非阻塞地获取锁、获取可中断锁以及尝试获取锁直到超时。
    • ReentrantLock：一个实现了Lock接口的可重入互斥锁。
    • ReadWriteLock接口：读写锁，允许多个线程同时读共享资源，但只有一个线程可以写。
    • ReentrantReadWriteLock：实现了ReadWriteLock，提供了读写分离的锁管理机制。

      示例（使用ReentrantLock ）：

      import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class ReentrantLockExample {    private final Lock lock = new ReentrantLock();    public void task() {        lock.lock();        try {            System.out.println("Task executed by " + Thread.currentThread().getName());            // 模拟任务执行        } finally {            lock.unlock();        }    }    public static void main(String[] args) {        ReentrantLockExample example = new ReentrantLockExample();        Thread t1 = new Thread(example::task);        Thread t2 = new Thread(example::task);        t1.start();        t2.start();    }}

       

      并发集合

      java.util.concurrent包提供了多种线程安全的集合类。

      • ConcurrentHashMap：一个高效的线程安全的HashMap实现。
      • CopyOnWriteArrayList和CopyOnWriteArraySet：写时复制技术的应用，适合读多写少的并发场景。
      • BlockingQueue接口：支持两个附加操作的Queue，即在队列为空时获取元素的线程会等待队列变为非空，队列满时插入元素的线程会等待队列可用。

         示例（使用ConcurrentHashMap）：

        import java.util.concurrent.ConcurrentHashMap;public class ConcurrentHashMapExample {    public static void main(String[] args) {        ConcurrentHashMap map = new ConcurrentHashMap();        map.put("key", "value");        System.out.println(map.get("key"));    }}

         

        原子变量

        在java.util.concurrent.atomic包中，提供了一组原子类用于在单个变量上进行无锁的线程安全操作。

        • AtomicInteger、AtomicLong、AtomicBoolean等：提供了基本类型的原子操作。
        • AtomicReference：提供了对象引用的原子操作。
        • AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray：提供了数组元素的原子操作。

          示例（使用AtomicInteger）:

          import java.util.concurrent.atomic.AtomicInteger;public class AtomicIntegerExample {    private static AtomicInteger counter = new AtomicInteger(0);    public static void main(String[] args) {        // 线程1增加计数器        new Thread(() -> counter.incrementAndGet()).start();        // 线程2增加计数器        new Thread(() -> counter.incrementAndGet()).start();        System.out.println("Counter: " + counter.get());    }}

           

          CompletableFuture

          CompletableFuture是在Java 8中引入的，提供了一个异步编程的框架。通过CompletableFuture，可以将回调式的编程风格与Future的优势结合起来，实现更加灵活的异步编程。

          示例

          import java.util.concurrent.CompletableFuture;import java.util.concurrent.ExecutionException;public class CompletableFutureExample {    public static void main(String[] args) throws ExecutionException, InterruptedException {        CompletableFuture future = CompletableFuture.supplyAsync(() -> {            return "Hello from CompletableFuture";        });        // 等待异步操作完成并获取结果        String result = future.get();        System.out.println(result);    }}

           

          总结

          Java的并发包java.util.concurrent提供了一套强大的工具集，用于简化多线程程序的开发。无论是执行大量异步任务的线程池管理，还是精细的线程同步控制，或是高效的并发数据结构，Java并发包都能提供相应的解决方案。通过合理利用这些工具，可以大幅提升Java应用程序的性能、可靠性和可维护性。了解并掌握这些并发工具，对于每一个Java开发者来说都是非常重要的。