java实现多线程的几种方式

Java实现多线程的几种方式

创新互联专注为客户提供全方位的互联网综合服务，包含不限于成都网站设计、成都做网站、麒麟网络推广、成都微信小程序、麒麟网络营销、麒麟企业策划、麒麟品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；创新互联为所有大学生创业者提供麒麟建站搭建服务，24小时服务热线：028-86922220，官方网址：www.cdcxhl.com

Java 提供了多种方式来实现多线程，主要包括以下几种：

1、继承 Thread 类

2、实现 Runnable 接口

3、使用 ExecutorService 和 Callable

4、使用 Fork/Join 框架

5、使用 CompletableFuture

6、使用 Parallel Streams

1. 继承 Thread 类

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

class MyThread extends Thread {
    @Override
    public void run() {
        // 线程要执行的任务
    }
}
public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); // 启动线程
    }
}

2. 实现 Runnable 接口

实现 Runnable 接口并重写其 run() 方法，可以创建一个新的线程，将实现了 Runnable 接口的类的对象作为参数传递给 Thread 类的构造函数，然后调用 start() 方法来启动线程。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程要执行的任务
    }
}
public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // 启动线程
    }
}

3. 使用 ExecutorService 和 Callable

ExecutorService 是一个线程池，可以用来管理和控制线程。Callable 是一个返回结果并可能抛出异常的任务，通过将 Callable 任务提交给 ExecutorService，可以实现多线程。

import java.util.concurrent.*;
class MyCallable implements Callable {
    @Override
    public Integer call() throws Exception {
        // 线程要执行的任务
        return result;
    }
}
public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        MyCallable myCallable = new MyCallable();
        Future future = executorService.submit(myCallable);
        try {
            Integer result = future.get(); // 获取任务结果
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown(); // 关闭线程池
        }
    }
}

4. 使用 Fork/Join 框架

Fork/Join 框架是一个用于并行执行任务的框架，它利用多核处理器的优势，将大任务分解成小任务并行执行，然后将结果合并。

class MyRecursiveTask extends RecursiveTask {
    @Override
    protected Integer compute() {
        // 判断任务是否足够小，如果足够小则直接计算结果，否则将任务分解成子任务并行执行
        if (任务足够小) {
            return 计算结果；
        } else {
            List subTasks = 分解任务；
            subTasks.forEach(task > task.fork()); // 并行执行子任务
            Integer result = 0;
            for (MyRecursiveTask task : subTasks) {
                result += task.join(); // 等待子任务完成并合并结果
            }
            return result;
        }
    }
}
public class Main {
    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        MyRecursiveTask myRecursiveTask = new MyRecursiveTask();
        Integer result = forkJoinPool.invoke(myRecursiveTask); // 执行任务并获取结果
    }
}

5. 使用 CompletableFuture

CompletableFuture 是 Java 8 引入的一个异步编程工具，它可以实现异步任务的串行和并行执行，以及任务结果的处理。

import java.util.concurrent.CompletableFuture;
public class Main {
    public static void main(String[] args) {
        CompletableFuture future = CompletableFuture.runAsync(() > {
            // 线程要执行的任务
        });
        future.thenRun(() > {
            // 任务完成后要执行的操作
        });
    }
}

6. 使用 Parallel Streams

Parallel Streams 是 Java 8 引入的一个并行处理数据的工具，它可以利用多核处理器的优势，将数据处理任务并行执行。

import java.util.stream.IntStream;
public class Main {
    public static void main(String[] args) {
        List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        numbers.parallelStream().forEach(number > {
            // 并行处理每个数字
        });
    }
}