Java多线程最佳实践指南-编程学习网

1. 使用线程池

线程池可以有效地管理线程的创建和销毁，复用线程资源，减少开销。

示例代码：使用线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executorService.submit(() -> {
                System.out.println("执行任务: " + Thread.currentThread().getName());
            });
        }
        executorService.shutdown();
    }
}

2. 避免使用Thread.stop()

该方法已被弃用，因为它不安全，可能导致资源无法正确释放。

3. 使用volatile关键字

确保变量的更改对所有线程立即可见。

示例代码：使用volatile

public class VolatileExample {
    private static volatile boolean running = true;

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (running) {
                // 执行任务
            }
            System.out.println("线程已停止");
        });
        thread.start();
        running = false; // 改变变量状态，通知线程停止
    }
}

4. 使用Atomic类

确保操作的原子性。

示例代码：使用AtomicInteger

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        int numberOfThreads = 10;
        ExecutorService executorService = Executors.newFixedThreadPool(numberOfThreads);
        for (int i = 0; i < numberOfThreads; i++) {
            executorService.submit(() -> {
                counter.incrementAndGet();
            });
        }
        executorService.shutdown();
        try {
            executorService.awaitTermination(1, TimeUnit.SECONDS);
            System.out.println("最终计数: " + counter.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

5. 使用同步工具类

如CountDownLatch、CyclicBarrier、Semaphore等。

示例代码：使用CountDownLatch

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        final int totalThreads = 5;
        CountDownLatch latch = new CountDownLatch(totalThreads);
        for (int i = 0; i < totalThreads; i++) {
            new Thread(() -> {
                System.out.println("子线程: " + Thread.currentThread().getName() + " 执行完毕");
                latch.countDown();
            }).start();
        }
        latch.await();
        System.out.println("所有子线程执行完毕，主线程继续执行");
    }
}

6. 设计线程安全类

使用同步机制来确保线程安全。

示例代码：设计线程安全类

public class ThreadSafeClass {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

7. 限制线程数量

合理地限制线程数量，可以有效提高程序性能。

8. 正确处理线程异常

捕获并处理线程可能抛出的异常。

示例代码：正确处理线程异常

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadExceptionHandling {
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future future = executorService.submit(() -> {
            throw new RuntimeException("线程异常");
        });
        try {
            future.get(); // 等待线程完成
        } catch (ExecutionException e) {
            Throwable cause = e.getCause();
            if (cause instanceof RuntimeException) {
                System.out.println("捕获线程异常: " + cause.getMessage());
            }
        }
        executorService.shutdown();
    }
}

9. 使用Future和Callable

跟踪异步任务的状态和结果。

示例代码：使用Callable和Future

import java.util.concurrent.*;

public class FutureExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future future = executorService.submit(() -> {
            return 123;
        });
        Integer result = future.get(); // 获取结果
        System.out.println("任务结果: " + result);
        executorService.shutdown();
    }
}

10. 避免死锁

通过使用锁排序、超时机制等方法来避免死锁。

示例代码：避免死锁

import java.util.concurrent.locks.*;

public class DeadlockAvoidance {
    private static final ReentrantLock lock1 = new ReentrantLock();
    private static final ReentrantLock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        new Thread(() -> {
            lock1.lock();
            try {
                Thread.sleep(100);
                lock2.lock();
                try {
                    // 执行任务
                } finally {
                    lock2.unlock();
                }
            } finally {
                lock1.unlock();
            }
        }).start();
    }
}

11. 使用ThreadLocal

为每个线程提供独立实例的变量。

示例代码：使用ThreadLocal

public class ThreadLocalExample {
    private static ThreadLocal threadLocalValue = new ThreadLocal<>();

    public static void main(String[] args) {
        new Thread(() -> {
            threadLocalValue.set(10);
            System.out.println("线程 " + Thread.currentThread().getName() + " 的值: " + threadLocalValue.get());
        }).start();
        new Thread(() -> {
            threadLocalValue.set(20);
            System.out.println("线程 " + Thread.currentThread().getName() + " 的值: " + threadLocalValue.get());
        }).start();
    }
}

12. 进行性能测试

通过创建多个线程执行特定任务，并测量执行时间来评估性能。

示例代码：多线程性能测试

import java.util.concurrent.*;

public class PerformanceTest {
    public static void main(String[] args) throws InterruptedException {
        int threadSize = 100;
        ExecutorService executorService = Executors.newFixedThreadPool(threadSize);
        long start = System.currentTimeMillis();
        for (int j = 0; j < threadSize; j++) {
            executorService.execute(new Task());
        }
        executorService.shutdown();
        executorService.awaitTermination(Integer.MAX_VALUE, TimeUnit.DAYS);
        long end = System.currentTimeMillis();
        System.out.println("用时：" + (end - start) + "ms");
    }

    static class Task implements Runnable {
        public void run() {
            // 模拟任务
        }
    }
}

13. 使用CompletableFuture

简化回调模式，并提供更好的错误处理和异步结果组合。

示例代码：使用CompletableFuture

import java.util.concurrent.*;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture future = CompletableFuture.runAsync(() -> {
            System.out.println("异步任务执行");
        }).thenRun(() -> {
            System.out.println("第一个回调执行");
        }).exceptionally(ex -> {
            System.out.println("异常处理: " + ex.getMessage());
            return null;
        });
        future.join();
    }
}

14. 避免在循环中创建线程

使用线程池来管理线程。

示例代码：避免在循环中创建线程

import java.util.concurrent.*;

public class LoopThreadExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            executorService.submit(() -> {
                System.out.println("执行任务: " + Thread.currentThread().getName());
            });
        }
        executorService.shutdown();
    }
}

15. 使用UncaughtExceptionHandler

捕获并处理线程中未捕获的异常。

示例代码：使用UncaughtExceptionHandler

public class UncaughtExceptionHandlerExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            throw new RuntimeException("未捕获异常");
        });
        thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println("捕获未捕获异常: " + e.getMessage());
            }
        });
        thread.start();
    }
}