Java并发包JUC诞生及详细内容

背景

在 Java 5 之前，Java 并发编程是基于许多传统的线程类（如 Thread，Runnable）和锁（如 synchronized）。但是由于 Java 的线程模型提供了太多的灵活性，因此在编写并发应用程序时可能很容易犯错。而且，在多个线程之间共享资源并且执行顺序不一定一致的情况下，程序的执行结果可能是不确定的，又称为“竞态条件”。这很困难，并且很难进行调试和优化。

JUC 的诞生

Java 并发编程引入了 JUC（Java Util Concurrency）库，它是 Java 5 中新引入的。JUC 是一个用于并发编程的工具包，可以帮助 Java 开发人员更方便地设计和实现并发编程应用程序。JUC 提供了许多类，这些类可以帮助我们避免竞争条件、协调线程、管理线程等。

JUC 的重要内容

原子变量类

原子变量类可以保证变量在方法中以原子性的方式进行操作。原子性意味着对于多线程来说，该操作将是不可操作的（即不可分割的）。Java 提供了以下原子变量类：

1. AtomicInteger：一个用于 int 类型的原子变量类。
2. AtomicLong：一个用于 long 类型的原子变量类。
3. AtomicBoolean：一个用于 boolean 类型的原子变量类。

下面是 AtomicInteger 的使用示例：

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicTest {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);
        System.out.println("原始值：" + atomicInteger.get());
        atomicInteger.set(10);
        System.out.println("修改后的值：" + atomicInteger.get());
        atomicInteger.compareAndSet(10, 20);
        System.out.println("CAS操作后的值：" + atomicInteger.get());
    }
}

锁

JUC 中提供了诸多的锁，包括：

1. ReentrantLock：一个可重入锁，同一线程可以多次获取同一个锁。
2. Condition：与 Lock 一起使用，可以进行更加灵活的线程通信。
3. ReadWriteLock：一个读写锁，可以在读多写少的场景中提高并发性能。

以下是 ReentrantLock 的使用示例：

import java.util.concurrent.locks.ReentrantLock;

public class LockTest {
    static int count = 0;
    static ReentrantLock lock = new ReentrantLock(true);

    public static void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(count);
    }
}

并发集合

Java 提供了多种并发集合，包括：

1. ConcurrentHashMap：一个高性能的并发哈希表，支持并发读写。
2. CopyOnWriteArrayList：一个线程安全的可变列表，在修改列表时会创建一个新的副本，可以在不进行锁定的情况下进行并发访问。
3. BlockingQueue：支持线程间的阻塞式通信。

以下是 ConcurrentHashMap 的使用示例：

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapTest {
    public static void main(String[] args) {
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");
        System.out.println("原始值：" + map);
        map.put("key3", "new-value3");
        System.out.println("修改后的值：" + map);
        map.remove("key1");
        System.out.println("删除后的值：" + map);
    }
}

并行计算框架

JUC 还提供了两个重要的并行计算框架：

1. Fork/Join 框架：用于并行执行递归任务。
2. CompletableFuture：可以帮助我们处理异步任务。

以下是 CompletableFuture 的使用示例：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureTest {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello";
        });

        future.thenAccept(result -> {
            System.out.println(result + " world");
        });

        System.out.println("异步任务已提交");
    }
}

结论

JUC 是一个功能强大而且使用非常方便的工具包，可以帮助 Java 开发人员处理并发编程中的复杂问题。尽管有些类可能需要花一些时间来理解和学习，但是一旦掌握了这些类，你将可以更快、更安全、更容易地编写高效的并发程序。