当前位置：首页 > Java

java如何实现并发

2026-03-04 01:05:56Java

Java 并发实现方式

Java 提供了多种实现并发的机制，主要包括线程、线程池、并发工具类和异步编程等。以下是具体的实现方式：

线程基础

创建线程可以通过继承 Thread 类或实现 Runnable 接口。推荐使用 Runnable 接口，因为 Java 不支持多重继承，而接口可以更灵活地扩展。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

线程池

使用线程池可以避免频繁创建和销毁线程的开销。Java 提供了 ExecutorService 框架来管理线程池。

java如何实现并发

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

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executor.execute(() -> {
                System.out.println("Task executed by " + Thread.currentThread().getName());
            });
        }
        executor.shutdown();
    }
}

并发工具类

Java 提供了多种并发工具类，如 CountDownLatch、CyclicBarrier、Semaphore 和 BlockingQueue，用于协调多线程之间的同步。

import java.util.concurrent.CountDownLatch;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        new Thread(() -> {
            System.out.println("Task 1 done");
            latch.countDown();
        }).start();
        new Thread(() -> {
            System.out.println("Task 2 done");
            latch.countDown();
        }).start();
        new Thread(() -> {
            System.out.println("Task 3 done");
            latch.countDown();
        }).start();
        latch.await();
        System.out.println("All tasks completed");
    }
}

异步编程

Java 8 引入了 CompletableFuture，支持异步编程和函数式编程风格。

java如何实现并发

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            return "Hello, World!";
        });
        System.out.println(future.get());
    }
}

锁机制

Java 提供了 synchronized 关键字和 ReentrantLock 类来实现线程同步。

import java.util.concurrent.locks.ReentrantLock;

public class Main {
    private static final ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        lock.lock();
        try {
            System.out.println("Critical section");
        } finally {
            lock.unlock();
        }
    }
}

原子类

Java 提供了 AtomicInteger、AtomicLong 等原子类，用于无锁线程安全操作。

import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    private static final AtomicInteger counter = new AtomicInteger(0);
    public static void main(String[] args) {
        System.out.println(counter.incrementAndGet());
    }
}