Java并发工具类详解：从Executors到CompletableFuture

Java并发工具类详解：从Executors到CompletableFuture

大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！

一、Java并发编程基础
Java并发编程是利用多线程来提高程序性能和响应能力的关键技术。Java提供了丰富的并发工具来帮助开发者编写高效的并发程序。

二、Executor框架
Executor框架是Java并发编程的核心，它定义了任务的执行方式。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import cn.juwatech.task.MyRunnable;

public class ExecutorExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 10; i++) {
            executor.submit(new MyRunnable());
        }
        executor.shutdown();
    }
}

三、Executors的几种线程池
Executors提供了几种静态工厂方法来创建不同类型的线程池。

// 创建一个固定大小的线程池
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);

// 创建一个单线程的线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

// 创建一个可缓存的线程池
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

四、Callable与Future
Callable任务可以返回结果，并且可以抛出异常。Future用于获取Callable任务的结果。

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import cn.juwatech.task.MyCallable;

public class CallableExample {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(1);
        Future<String> future = executor.submit(new MyCallable());
        System.out.println("Result: " + future.get());
        executor.shutdown();
    }
}

五、同步辅助工具类
CountDownLatch、CyclicBarrier、Semaphore和Exchanger是Java提供的同步辅助工具类。

import java.util.concurrent.CountDownLatch;

public class LatchExample {
    public static void main(String[] args) throws InterruptedException {
        int threadCount = 5;
        CountDownLatch latch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            new Thread(new LatchTask(latch)).start();
        }
        latch.await(); // 等待所有线程完成
        System.out.println("All tasks completed.");
    }
}

class LatchTask implements Runnable {
    private final CountDownLatch latch;

    public LatchTask(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        try {
            // 执行任务
        } finally {
            latch.countDown();
        }
    }
}

六、并发集合
Java提供了一些并发集合类，如ConcurrentHashMap、CopyOnWriteArrayList等。

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentCollectionExample {
    public static void main(String[] args) {
        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
        // 线程安全的Map操作
    }
}

七、Fork/Join框架
Fork/Join框架是Java 7中引入的，用于并行处理任务。

import java.util.concurrent.RecursiveTask;
import cn.juwatech.task.MyForkJoinTask;

public class ForkJoinExample {
    public static void main(String[] args) {
        MyForkJoinTask task = new MyForkJoinTask(0, 1000 * 1000);
        task.fork(); // 并行计算
    }
}

八、CompletableFuture
CompletableFuture是Java 8中引入的，用于编写异步的非阻塞代码。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            // 模拟长时间运行的任务
            return "Result";
        }).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(ex -> {
            ex.printStackTrace();
            return null;
        });
    }
}

九、CompletableFuture的组合使用
多个CompletableFuture可以组合使用，实现更复杂的异步逻辑。

CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
    // 异步任务1
});
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    // 异步任务2
    return "Data";
});

future2.thenAcceptBoth(future1, (data, ignored) -> {
    // 两个任务都完成后的逻辑
});

十、线程工厂
自定义线程工厂可以创建具有特定属性的线程。

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
import cn.juwatech.thread.MyThreadFactory;

public class ThreadFactoryExample {
    public static void main(String[] args) {
        ThreadFactory factory = new MyThreadFactory();
        Thread thread = factory.newThread(() -> {
            // 线程任务
        });
        thread.start();
    }
}

class MyThreadFactory implements ThreadFactory {
    private final AtomicInteger count = new AtomicInteger(1);

    @Override
    public Thread newThread(Runnable r) {
        return new Thread(r, "CustomThread-" + count.getAndIncrement());
    }
}

本文著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！