Java并发编程的概念和实现

最新推荐文章于 2025-10-04 14:23:41 发布

原创最新推荐文章于 2025-10-04 14:23:41 发布 · 811 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

Java并发编程的概念和实现

Java并发编程是Java语言中用于实现多任务并行执行的技术，它允许程序同时处理多个操作，从而提高应用程序的性能和响应能力。核心目标是解决资源竞争、数据一致性和任务协调等问题。下面我将从概念和实现两方面逐步解释，并提供代码示例。

一、并发编程的核心概念

并发与并行：
- 并发（Concurrency）：指多个任务在单核或多核处理器上交替执行，模拟同时运行的效果（例如，通过时间片轮转）。
- 并行（Parallelism）：指多个任务在多核处理器上真正同时执行。
- 在Java中，并发主要通过线程（Thread）实现，而并行依赖于硬件支持。
线程（Thread）：
- 线程是程序执行的最小单元。Java中每个线程都有自己的栈和程序计数器，但共享堆内存。
- 优点：轻量级，创建和切换成本低。
- 缺点：需管理同步，避免竞态条件（Race Condition）。
同步机制：
- 用于协调多个线程对共享资源的访问，防止数据不一致。
- 关键概念：
  - 互斥锁（Mutex）：确保一次只有一个线程访问临界区。
  - 条件变量（Condition）：让线程等待特定条件满足。
  - 原子操作（Atomicity）：操作不可中断，如Java的AtomicInteger。
- 常见问题：
  - 死锁（Deadlock）：多个线程相互等待资源释放。
  - 活锁（Livelock）：线程不断重试但无法进展。
  - 解决方法：使用锁超时、避免嵌套锁。
Java并发模型：
- 基于共享内存模型：线程通过共享对象通信。
- Java内存模型（JMM）定义了线程间变量的可见性规则（如volatile关键字确保最新值）。
- 工具包：java.util.concurrent（JUC）提供高级API，如线程池、并发集合。

二、实现方式及代码示例

Java提供了多种实现并发的机制，从基础线程创建到高级框架。以下是常见实现方法，附代码示例。

创建线程的基本方式：

扩展Thread类：重写run()方法。

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread running: .currentThread().getName());
    }
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // 启动线程
    }
}

实现Runnable接口：更灵活，推荐使用（避免单继承限制）。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(unnable running:  Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        Thread t2 = new Thread(new MyRunnable());
        t2.start();
    }
}

同步机制实现：

使用synchronized关键字：锁定对象或方法，确保原子性。

public class Counter {
    private int count = 0;
    public synchronized void increment() { // 同步方法
        count  ;
    }
    public int getCount() {
        return count;
    }
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i  ) counter.increment();
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i  ) counter.increment();
        });
        t1.start();
        t2.start();
        t1.join(); // 等待线程结束
        t2.join();
        System.out.println(Final count:  counter.getCount()); // 应输出2000
    }
}

使用Lock接口：更灵活的锁机制（如ReentrantLock），支持超时和条件变量。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockExample {
    private final Lock lock = new ReentrantLock();
    private int value = 0;
    public void increment() {
        lock.lock(); // 获取锁
        try {
            value  ;
        } finally {
            lock.unlock(); // 释放锁
        }
    }
    public static void main(String[] args) throws InterruptedException {
        LockExample example = new LockExample();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i  ) example.increment();
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i  ) example.increment();
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(Final value:  example.value); // 应输出2000
    }
}

高级并发工具：

Executor框架：管理线程池，避免手动创建线程（推荐用于生产环境）。

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( 2 executed by    Thread.currentThread().getName()));
        executor.shutdown(); // 关闭线程池
    }
}

CompletableFuture：处理异步任务链，支持回调和非阻塞。

import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> Hello\n                 .thenApply(s -> s   \thenAccept(System.out::println); // 输出 Hello World\n         }
}

三、最佳实践和注意事项

性能优化：使用线程池（如Executors.newCachedThreadPool()）避免频繁创建线程，资源消耗近似 $O (1)$ 。
避免常见问题：
- 使用volatile保证变量可见性。
- 优先使用JUC工具（如ConcurrentHashMap）而非手动同步。
- 测试并发代码时，模拟高负载场景。
学习资源：推荐Java官方文档的并发章节，或书籍《Java并发编程实战》。