当前位置：首页 > 后端开发 > 正文

java怎么同时起多个线程

admin
后端开发
2025-08-09
7

Java中，可以通过继承Thread类或实现Runnable接口来创建线程，然后调用 start()方法启动多个线程。，“`java，Thread t1 = new Thread(() -> { / 任务代码 / });，Thread t2 = new Thread(() -> { / 任务代码 / });，t1.start();，t2.

Java中，同时启动多个线程可以通过多种方式实现,以下是几种常见的方法及其详细解释：

继承Thread类

通过继承Thread类并重写其run()方法，可以创建一个新的线程，通过调用start()方法来启动线程。

public class MyThread extends Thread { @Override public void run() { System.out.println("Thread " + Thread.currentThread().getId() + " is running"); } public static void main(String[] args) { for (int i = 0; i < 5; i++) { MyThread thread = new MyThread(); thread.start(); } } }

实现Runnable接口

通过实现Runnable接口并重写其run()方法，可以将任务传递给Thread对象来启动线程。

使用ExecutorService

ExecutorService是Java并发库中的一个接口，它提供了一种更高级别的线程管理方式，通过ExecutorService,可以方便地提交任务并控制线程的生命周期。

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ExecutorExample { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(5); for (int i = 0; i < 5; i++) { executor.submit(() -> { System.out.println("Thread " + Thread.currentThread().getId() + " is running"); }); } executor.shutdown(); } }

使用ForkJoinPool

ForkJoinPool是Java并发库中的一个特殊类型的ExecutorService,它适用于递归任务的并行执行。

import java.util.concurrent.ForkJoinPool; import java.util.concurrent.RecursiveAction; public class ForkJoinExample { static class MyTask extends RecursiveAction { @Override protected void compute() { System.out.println("Thread " + Thread.currentThread().getId() + " is running"); } public static void main(String[] args) { ForkJoinPool pool = new ForkJoinPool(); for (int i = 0; i < 5; i++) { pool.invoke(new MyTask()); } pool.shutdown(); } } }

使用CompletableFuture

CompletableFuture是Java 8引入的一个类，用于异步编程,它可以方便地处理多个并发任务。

import java.util.concurrent.CompletableFuture; public class CompletableFutureExample { public static void main(String[] args) { for (int i = 0; i < 5; i++) { CompletableFuture.runAsync(() -> { System.out.println("Thread " + Thread.currentThread().getId() + " is running"); }); } } }

使用Parallel Streams

Java 8引入的并行流（Parallel Streams）可以自动将任务分配到多个线程中执行。

import java.util.List; import java.util.Arrays; public class ParallelStreamExample { public static void main(String[] args) { List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); list.parallelStream().forEach(i -> { System.out.println("Thread " + Thread.currentThread().getId() + " is processing " + i); }); } }

使用Phaser

Phaser是Java 7引入的一个同步工具,用于控制多个线程的执行阶段。

import java.util.concurrent.Phaser; public class PhaserExample { public static void main(String[] args) { Phaser phaser = new Phaser(1); for (int i = 0; i < 5; i++) { new Thread(() -> { phaser.arriveAndAwaitAdvance(); System.out.println("Thread " + Thread.currentThread().getId() + " is running"); phaser.arriveAndDeregister(); }).start(); } } }

使用CountDownLatch

CountDownLatch是一个同步工具类,允许一个或多个线程等待一组其他线程完成操作。

import java.util.concurrent.CountDownLatch; public class CountDownLatchExample { public static void main(String[] args) { CountDownLatch latch = new CountDownLatch(5); for (int i = 0; i < 5; i++) { new Thread(() -> { System.out.println("Thread " + Thread.currentThread().getId() + " is running"); latch.countDown(); }).start(); } try { latch.await(); System.out.println("All threads are finished"); } catch (InterruptedException e) { e.printStackTrace(); } } }

使用CyclicBarrier

CyclicBarrier是一个同步工具类，允许一组线程互相等待,直到所有线程都达到某个状态。

import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; public class CyclicBarrierExample { public static void main(String[] args) { CyclicBarrier barrier = new CyclicBarrier(5); for (int i = 0; i < 5; i++) { new Thread(() -> { try { barrier.await(); System.out.println("Thread " + Thread.currentThread().getId() + " is running"); } catch (InterruptedException | BrokenBarrierException e) { e.printStackTrace(); } }).start(); } } }

使用Semaphore

Semaphore是一个同步工具类,用于控制对资源的访问。

import java.util.concurrent.Semaphore; public class SemaphoreExample { public static void main(String[] args) { Semaphore semaphore = new Semaphore(5); for (int i = 0; i < 5; i++) { new Thread(() -> { try { semaphore.acquire(); System.out.println("Thread " + Thread.currentThread().getId() + " is running"); semaphore.release(); } catch (InterruptedException e) { e.printStackTrace(); } }).start(); } } }