JAVA并发-多线程

真真假假々

于 2024-07-27 15:32:30 发布

阅读量723

点赞数 21

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_53793319/article/details/140735628

版权

一、线程的定义：

线程（Thread）是程序中执行的单元，是操作系统能够进行运算调度的最小单位。一个进程可以包含多个线程，每个线程都是独立运行的，但它们共享相同的内存空间和资源。

二、使用多线程的原因：

1、提高响应性： 允许程序执行多个任务，例如同时处理用户输入、网络请求和后台计算，从而增加系统响应速度和用户体验。

2、提高效率： 能够利用多核处理器并行计算，加快任务执行速度。

3、简化复杂性： 使用多线程可以更方便地组织和管理多个并发任务，使得程序结构更加清晰和模块化。

三、创建线程的几种常见方式：

1、继承 Thread 类

通过继承 Thread 类并重写 run() 方法来创建线程。

public class MyThread extends Thread {
    
    @Override
    public void run() {
        System.out.println("Thread running - extending Thread class.");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}

2、实现 Runnable 接口

实现 Runnable 接口并传入 Thread 构造函数，这种方式更灵活，因为 Java 不支持多重继承，但是可以实现多个接口。

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("Thread running - implementing Runnable interface.");
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start(); // 启动线程
    }
}

3、使用 Callable 和 FutureTask

通过实现 Callable 接口和使用 FutureTask 类，可以获取线程的执行结果或者取消线程的执行。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class MyCallable implements Callable<String> {

    @Override
    public String call() {
        return "Callable thread running.";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(futureTask);
        thread.start();

        String result = futureTask.get(); // 获取线程执行结果
        System.out.println(result);
    }
}

4、使用 Executor 框架

通过 ExecutorService 和 ThreadPoolExecutor 等类来管理和调度线程池中的线程，更好地管理线程资源。

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

public class ThreadPoolExample {

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5); // 创建固定大小的线程池

        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("Task " + i);
            executor.execute(worker); // 提交任务给线程池执行
        }

        executor.shutdown(); // 关闭线程池
        while (!executor.isTerminated()) {
            // 等待所有任务完成
        }
        System.out.println("所有的任务已完成");
    }

    private static class WorkerThread implements Runnable {
        private String task;

        public WorkerThread(String task) {
            this.task = task;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " Start. Task = " + task);
            processTask();
            System.out.println(Thread.currentThread().getName() + " End.");
        }

        private void processTask() {
            // 模拟任务执行
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}