Java 并发编程代码示例

原创 已于 2025-11-20 22:45:58 修改 · 272 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

于 2025-11-20 22:38:31 首次发布

Java 并发编程的核心是 多线程协作、共享资源同步、线程池管理 等，以下是覆盖核心场景的代码示例，包含注释和场景说明，适合学习和实际参考：

一、基础场景：创建线程（3种常用方式）

1. 继承 Thread 类
// 场景：简单独立任务，无返回值
class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行逻辑
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
            try {
                Thread.sleep(100); // 模拟任务耗时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        thread1.setName("Thread-1");
        thread2.setName("Thread-2");
        
        thread1.start(); // 启动线程（调用 run() 方法）
        thread2.start();
    }
}
2. 实现 Runnable 接口（推荐，解耦线程与任务）
// 场景：多线程共享同一个任务实例（无返回值）
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        // 共享任务实例
        MyRunnable task = new MyRunnable();
        // 线程池（推荐替代直接 new Thread）
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.submit(new Thread(task, "Runnable-1"));
        executor.submit(new Thread(task, "Runnable-2"));
        
        executor.shutdown(); // 关闭线程池（等待任务执行完）
    }
}
3. 实现 Callable 接口（有返回值，支持异常抛出）
// 场景：需要获取线程执行结果（如计算任务）
class MyCallable implements Callable<Integer> {
    private int num;

    public MyCallable(int num) {
        this.num = num;
    }

    // 有返回值，可抛出异常
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= num; i++) {
            sum += i;
            Thread.sleep(50);
        }
        System.out.println(Thread.currentThread().getName() + " 计算完成");
        return sum;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        // 提交任务，返回 Future 对象（用于获取结果）
        Future<Integer> future1 = executor.submit(new MyCallable(10));
        Future<Integer> future2 = executor.submit(new MyCallable(20));
        
        // 获取结果（阻塞等待线程执行完）
        System.out.println("Callable-1 结果：" + future1.get());
        System.out.println("Callable-2 结果：" + future2.get());
        
        executor.shutdown();
    }
}

二、核心场景：共享资源同步（解决线程安全问题）

1. synchronized 关键字（锁方法/代码块）
// 场景：多线程操作共享变量（如计数器），避免并发修改异常
class Counter {
    private int count = 0;

    // 方式1：锁整个方法
    public synchronized void increment() {
        count++;
    }

    // 方式2：锁代码块（更灵活，锁粒度更小）
    public void decrement() {
        synchronized (this) { // 锁对象（通常是当前实例或类对象）
            count--;
        }
    }

    public int getCount() {
        return count;
    }
}

public class SynchronizedDemo {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        ExecutorService executor = Executors.newFixedThreadPool(10);

        // 10个线程同时执行 increment，共执行1000次
        for (int i = 0; i < 1000; i++) {
            executor.submit(counter::increment);
        }

        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.SECONDS); // 等待所有线程执行完

        System.out.println("最终计数：" + counter.getCount()); // 正确结果：1000（无同步会小于1000）
    }
}
2. ReentrantLock（可重入锁，比 synchronized 更灵活）
// 场景：需要手动控制锁的获取/释放，支持公平锁、条件变量等
class ReentrantLockCounter {
    private int count = 0;
    // 可重入锁（参数 true 表示公平锁，按线程等待顺序获取锁）
    private final Lock lock = new ReentrantLock(true);

    public void increment() {
        lock.lock(); // 获取锁（未获取到则阻塞）
        try {
            count++; // 临界区（共享资源操作）
        } finally {
            lock.unlock(); // 必须在 finally 中释放锁，避免死锁
        }
    }

    public int getCount() {
        return count;
    }
}

public class ReentrantLockDemo {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLockCounter counter = new ReentrantLockCounter();
        ExecutorService executor = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 1000; i++) {
            executor.submit(counter::increment);
        }

        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.SECONDS);

        System.out.println("最终计数：" + counter.getCount()); // 1000
    }
}
3. 原子类（无锁同步，基于 CAS 机制）
// 场景：简单的数值增减，无需锁，性能更高
public class AtomicDemo {
    public static void main(String[] args) throws InterruptedException {
        // 原子整数（线程安全的自增/自减）
        AtomicInteger atomicCount = new AtomicInteger(0);
        ExecutorService executor = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 1000; i++) {
            // incrementAndGet()：原子自增并返回新值
            executor.submit(atomicCount::incrementAndGet);
        }

        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.SECONDS);

        System.out.println("最终计数：" + atomicCount.get()); // 1000
    }
}

三、高级场景：线程协作（等待/通知机制）

1. Condition 条件变量（配合 ReentrantLock）
// 场景：生产者-消费者模型（线程间协作，避免忙等）
class MessageQueue {
    private final Queue<String> queue = new LinkedList<>();
    private final Lock lock = new ReentrantLock();
    // 条件变量：队列非空（消费者等待）、队列未满（生产者等待）
    private final Condition notEmpty = lock.newCondition();
    private final Condition notFull = lock.newCondition();
    private final int capacity = 5; // 队列最大容量

    // 生产者放入消息
    public void put(String message) throws InterruptedException {
        lock.lock();
        try {
            // 队列满了，生产者等待
            while (queue.size() == capacity) {
                notFull.await(); // 释放锁，进入等待队列
            }
            queue.offer(message);
            System.out.println("生产者放入：" + message);
            notEmpty.signal(); // 通知消费者：队列非空了
        } finally {
            lock.unlock();
        }
    }

    // 消费者取出消息
    public String take() throws InterruptedException {
        lock.lock();
        try {
            // 队列为空，消费者等待
            while (queue.isEmpty()) {
                notEmpty.await();
            }
            String message = queue.poll();
            System.out.println("消费者取出：" + message);
            notFull.signal(); // 通知生产者：队列未满了
            return message;
        } finally {
            lock.unlock();
        }
    }
}

public class ConditionDemo {
    public static void main(String[] args) {
        MessageQueue queue = new MessageQueue();
        ExecutorService executor = Executors.newFixedThreadPool(4);

        // 2个生产者
        executor.submit(() -> {
            try {
                queue.put("消息1");
                queue.put("消息2");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executor.submit(() -> {
            try {
                queue.put("消息3");
                queue.put("消息4");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 2个消费者
        executor.submit(() -> {
            try {
                queue.take();
                queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executor.submit(() -> {
            try {
                queue.take();
                queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        executor.shutdown();
    }
}
2. CountDownLatch（线程等待多任务完成）
// 场景：主线程等待所有子线程执行完再继续（如并行计算汇总结果）
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        int threadNum = 3;
        // 计数器初始值 = 线程数
        CountDownLatch latch = new CountDownLatch(threadNum);

        ExecutorService executor = Executors.newFixedThreadPool(threadNum);
        for (int i = 0; i < threadNum; i++) {
            int taskId = i;
            executor.submit(() -> {
                try {
                    System.out.println("任务" + taskId + "执行中...");
                    Thread.sleep(1000);
                    System.out.println("任务" + taskId + "执行完成");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown(); // 计数器减1
                }
            });
        }

        System.out.println("主线程等待所有任务完成...");
        latch.await(); // 主线程阻塞，直到计数器为0
        System.out.println("所有任务完成，主线程继续执行");

        executor.shutdown();
    }
}

四、线程池（推荐：控制线程数量，避免资源耗尽）

Java 推荐用 ThreadPoolExecutor 自定义线程池（避免 Executors 工具类的默认缺陷）：

public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 核心参数说明：
        // 1. 核心线程数（常驻线程）：2
        // 2. 最大线程数：5
        // 3. 空闲线程存活时间：60秒（超过核心线程数的线程，空闲60秒后销毁）
        // 4. 时间单位：秒
        // 5. 任务队列（阻塞队列）：容量10（超出核心线程数的任务先入队）
        // 6. 线程工厂（创建线程的方式）：默认
        // 7. 拒绝策略（队列满+最大线程数满时，如何处理新任务）：抛异常
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                2,
                5,
                60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(10),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

        // 提交15个任务（核心2 + 队列10 + 最大3 = 15，刚好不触发拒绝策略）
        for (int i = 0; i < 15; i++) {
            int taskId = i;
            executor.submit(() -> {
                System.out.println("线程" + Thread.currentThread().getId() + "执行任务" + taskId);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown(); // 平缓关闭：等待已提交的任务执行完，不再接收新任务
        // executor.shutdownNow(); // 强制关闭：立即中断正在执行的任务，返回未执行的任务
    }
}

关键说明：

  1. 线程安全：共享资源必须通过 synchronized、Lock、原子类等方式同步，否则会出现 ConcurrentModificationException 或数据不一致；
  2. 线程池：避免直接 new Thread()，线程池可复用线程、控制并发数，降低资源开销；
  3. 协作机制：Condition、CountDownLatch、CyclicBarrier 等工具类可实现复杂的线程协作，比 wait()/notify() 更灵活；
  4. 异常处理：线程中未捕获的异常会导致线程终止，建议在 run()/call() 中统一捕获异常。
Java 并发编程常用锁总结
Austin_的博客
05-21 1302
Java 并发编程常用锁总结
Java并发编程：理解线程、同步和锁
宋小黑的博客
06-22 1493
Java提供了一套完备的并发编程工具，从基本的线程控制到复杂的锁机制和并发集合，这些工具帮助开发者构建稳健的多线程应用程序。原子类提供的主要优势是无锁的线程安全性，这通常比使用锁或其他同步机制具有更高的性能，特别是在高竞争的环境中。在Java并发编程中，除了锁和同步方法，条件变量和阻塞队列也是重要的工具，用于在多线程环境中协调线程之间的操作。阻塞队列是支持两个附加操作的队列，这些操作包括在队列为空时队列的获取操作将阻塞，等待队列变为非空，当队列满时插入操作将阻塞，等待队列可用。
2-《Java并发编程实战》(Java Concurrency in Practice) 代码示例
孙小鸿的博客
01-13 630
这是针对《Java并发编程实战》(Java Concurrency in Practice)一书中的示例代码进行扩展，并且进行验证的完整代码，具体背景可看这篇文章：
JAVA并发编程
onlymscn的博客
10-09 1174
Java线程池的核心实现类是。：核心线程数，线程池常驻线程数：最大线程数：空闲线程存活时间workQueue：任务队列（如：线程工厂handler：拒绝策略（如。
java高并发代码示例,Java使用代码模拟高并发操作的示例
weixin_36124208的博客
03-09 852
在java中，使用了synchronized关http://www.cppcns.com键字和Lock锁实现了资源的并发访问控制，在同一时间只允许唯一了线程进入临界区访问资源(读锁除外)，这样子控制的主要目的是为了解决多个线程并发同一资源造成的数据不一致的问题。在另外一种场景下，一个资源有多个副本可供同时使用，比如打印机房有多个打印机、厕所有多个坑可供同时使用，这种情况下，Java提供了另外的并发...
Java并发编程详解
林晓松
05-08 1278
本文章结合代码示例深入探讨了线程的基础概念、同步机制、并发工具类以及并发编程中的典型陷阱。
Java 并发编程
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
08-30 3221
线程创建、线程方法、线程同步、线程池、线程状态
全面详解Java并发编程：从基础到高级应用
热门推荐
微笑听雨
05-27 1万+
Java并发编程提供了强大的工具和框架，帮助开发者有效管理多线程任务，提升应用程序性能。理解并掌握基本概念、线程管理、同步机制和高级并发工具，并遵循最佳实践，可以编写出高效、安全、可靠的并发程序。
1-《Java并发编程实战》(Java Concurrency in Practice) 代码示例
孙小鸿的博客
01-13 1596
（摘自书中的原话）在基于Web的服务中，命中计数器值的少量偏差或许是可以接受的，在某些情况下也确实如此。但如果该计数器被用来生产数值序列或者唯一的对象标识符，那么在多次调用中返回相同的值将导致严重的数据完整性问题。这种由于不恰当的执行时许而出现的不正确的结果是一种非常重要的情况，它有一个正式的名字：竞态条件（Race Condition）。
好书推荐：Java并发编程相关
weixin_37522117的博客
12-30 652
好书推荐，java并发编程相关
精选资源
java并发编程实战源码,java并发编程实战pdf,Java
09-10
通过学习《Java并发编程实战》的源码，你可以更直观地了解这些概念如何在实际代码中实现，从而提升你的并发编程能力。在IDE中运行这些示例，可以加深对并发原理的理解，同时也能锻炼解决问题的能力。记住，实践是...
精选资源
java并发编程实战源码-jcip-examples:java并发编程实战
05-25
这本书深入浅出地介绍了Java并发编程的各种概念和技术，帮助开发者理解和掌握如何在多线程环境中编写高效、安全的代码。jcip-examples-master是与这本书配套的源码库，包含了书中所有示例代码，便于读者实践和学习。...
精选资源
java并发编程实战源码-concurrent-programming:《Java并发编程实战》源码整理
05-25
源码整理集合`concurrent-programming-master`提供了书中示例代码，对于学习和理解Java并发编程的概念、工具和最佳实践非常有帮助。 在Java并发编程中，以下几个核心知识点至关重要： 1. **线程与进程**：线程是...
并发编程Java代码示例.zip
12-27
"并发编程Java代码示例.zip"这个压缩包很可能是包含了一系列有关Java并发编程的实例代码，帮助开发者理解和掌握如何在Java中有效地管理多线程。 Java并发编程涉及到的关键概念和知识点包括： 1. **线程**：线程是...
精选资源
Java并发编程实战华章专业开发者书库 (Tim Peierls 等 美Brian Goetz).pdf
04-09
《Java并发编程实战》是一本深入探讨Java平台并发编程的权威指南，由Tim Peierls等人与Brian Goetz合著，旨在帮助Java开发者理解和掌握在多线程环境中编写高效、安全的代码。这本书由拥有丰富经验的JDK并发大师及...
01.05.01 Java 基础系列｜深入理解 BIO：从核心 API 到实战设计
u010105645的专栏
01-03 624
摘要：本文深入解析Java BIO（阻塞式I/O）编程，从核心API到生产级实现。BIO作为Java网络编程基础，采用同步阻塞模型，通过ServerSocket监听连接、Socket进行数据传输。文章演示了BIO的三个演进阶段：单线程模型（性能低下）、多线程模型（易资源耗尽）到最终的线程池伪异步模型（生产级方案）。重点讲解了线程池配置、资源管理、异常处理等实战技巧，并提供了完整的线程池BIO服务器实现代码，帮助开发者理解传统IO模型的核心原理及其适用场景。
阿里Java面试被问：单元测试的最佳实践
2501_94505843的博客
01-04 871
本文系统介绍了软件测试的最佳实践，主要包含以下内容：1. 测试金字塔原则，推荐70%单元测试+20%集成测试+10%端到端测试的比例；2. 测试代码质量标准，包括命名规范、AAA模式等；3. Mock与Stub的使用场景和区别；4. 测试数据管理策略；5. 断言最佳实践；6. 测试隔离与可重复性；7. 测试性能与维护建议；8. 边界条件测试方法；9. 有意义的测试覆盖率目标；10. TDD开发流程。文章提供了大量代码示例，并总结了单元测试检查清单和测试金字塔指导原则，强调应重点关注业务逻辑、复杂算法和边界条
面向微服务事件驱动与异步消息可靠处理的互联网系统高可用设计与多语言工程实践分享
最新发布
2501_94180531的博客
01-05 386
事件驱动解耦服务，提高吞吐可靠投递与幂等消费保证消息一致性监控、重试与顺序控制是稳定性的关键微服务事件驱动与异步消息可靠处理，使系统在高并发和复杂业务场景下保持稳定与可控。通过在多语言系统中统一幂等语义、结合可靠投递、顺序控制和监控策略，互联网系统能够在异步流程中实现高可用和长期可维护性。这篇关于事件驱动与异步消息可靠处理的工程实践分享，希望为你在微服务高可用设计中提供可落地、长期有效的参考思路。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值