多线程基本知识-CSDN博客

本文链接：https://blog.csdn.net/a1241436267/article/details/141404594

#线程的创建方式

一.通过继承Thread创建

1.创建一个类继承 Thread 类，并重写 run() 方法。
2.在 run() 方法中编写线程执行的代码。
3.实例化这个新类，并调用 start() 方法来启动线程

package com.ktjy.test;

/**
 * MyThread 类继承了 Thread 类，用于演示如何创建并运行一个简单的多线程程序
 */
class MyThread extends Thread {
    @Override
    public void run() {
        // 当线程启动后，将打印出线程的名称，以示区分
        System.out.println("你好，我是多线程 " + this.getName());
    }
}

/**
 * Main 类包含 main 方法，用于启动一个 MyThread 线程实例
 */
public class Main {
    public static void main(String[] args) {
        // 创建一个 MyThread 线程实例
        MyThread thread = new MyThread();
        // 启动线程，使其开始执行 run 方法中的代码
        thread.start();
    }
}

二.通过实现Runnable

package com.ktjy.test;

/**
 * 实现Runnable接口的自定义类，用于创建不可返回结果的多线程任务。
 */
class MyRunnable implements Runnable {
    /**
     * 当这个线程被调用时，将会执行这个方法。
     */
    @Override
    public void run() {
        System.out.println("你好，我是多线程 " + Thread.currentThread().getName());
    }
}

/**
 * 主类，用于演示如何使用自定义的Runnable类创建并执行多线程任务。
 */
public class Main {
    /**
     * 程序的入口点。
     *
     * @param args 命令行参数，本示例中未使用。
     */
    public static void main(String[] args) {
        // 创建一个MyRunnable对象，作为多线程任务。
        Runnable runnable = new MyRunnable();
        // 启动一个新的线程来执行runnable。
        new Thread(runnable).start();
    }
}

三.通过实现Callable

package com.ktjy.test;

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

/**
 * 实现Callable接口的自定义类，用于创建可返回结果的多线程任务。
 */
class MyCallable implements Callable<String> {
    /**
     * 当这个线程被调用时，将会执行这个方法。
     *
     * @return 返回一个包含当前线程名称的字符串，用来标识不同的线程。
     * @throws Exception 如果在执行过程中发生错误，可以抛出异常。
     */
    @Override
    public String call() throws Exception {
        return "你好，我是多线程 " + Thread.currentThread().getName();
    }
}

/**
 * 主类，用于演示如何使用自定义的Callable类创建并执行多线程任务。
 */
public class Main {
    /**
     * 程序的入口点。
     *
     * @param args 命令行参数，本示例中未使用。
     */
    public static void main(String[] args) {
        // 创建一个MyCallable对象，作为多线程任务。
        Callable<String> callable = new MyCallable();
        // 使用FutureTask包装Callable对象，以便能够获取线程的执行结果。
        FutureTask<String> futureTask = new FutureTask<>(callable);
        // 启动一个新的线程来执行futureTask。
        new Thread(futureTask).start();
        try {
            // 获取futureTask的执行结果，并打印出来。
            System.out.println(futureTask.get());
        } catch (Exception e) {
            // 处理可能发生的异常。
            e.printStackTrace();
        }
    }
}

#四种线程池

1.newCachedThreadPool - 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
2.newFixedThreadPool - 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
3.newScheduledThreadPool - 创建一个定长线程池，支持定时及周期性任务执行。
4.newSingleThreadExecutor - 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行。

这个Java程序演示了如何使用自定义的Runnable类创建并执行多线程任务。程序首先定义了一个实现Runnable接口的自定义类MyRunnable，其中的run方法包含了线程执行的逻辑。然后，在Main类的main方法中，创建了一个MyRunnable对象，并使用四种不同类型的线程池（CachedThreadPool、FixedThreadPool、ScheduledThreadPool和SingleThreadExecutor）来执行这个任务。最后，程序关闭线程池，并等待所有任务完成，然后输出线程池的状态。

package com.ktjy.test;

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

/**
 * 实现Runnable接口的自定义类，用于创建不可返回结果的多线程任务。
 */
class MyRunnable implements Runnable {
    /**
     * 当这个线程被调用时，将会执行这个方法。
     */
    @Override
    public void run() {
        System.out.println("你好，我是多线程 " + Thread.currentThread().getName());
    }
}

/**
 * 主类，用于演示如何使用自定义的Runnable类创建并执行多线程任务。
 */
public class Main {
    /**
     * 程序的入口点。
     *
     * @param args 命令行参数，本示例中未使用。
     */
    public static void main(String[] args) {
        // 创建一个MyRunnable对象，作为多线程任务。
        Runnable runnable = new MyRunnable();

        // 使用四种不同类型的线程池来执行任务
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
        ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

        // 提交任务到线程池
        cachedThreadPool.execute(runnable);
        fixedThreadPool.execute(runnable);
        scheduledThreadPool.execute(runnable);
        singleThreadExecutor.execute(runnable);

        // 关闭线程池
        cachedThreadPool.shutdown();
        fixedThreadPool.shutdown();
        scheduledThreadPool.shutdown();
        singleThreadExecutor.shutdown();

        // 等待所有任务完成
        while (!cachedThreadPool.isTerminated()) ;
        while (!fixedThreadPool.isTerminated()) ;
        while (!scheduledThreadPool.isTerminated()) ;
        while (!singleThreadExecutor.isTerminated()) ;

        // 输出线程池状态
        System.out.println("CachedThreadPool terminated: " + cachedThreadPool.isTerminated());
        System.out.println("FixedThreadPool terminated: " + fixedThreadPool.isTerminated());
        System.out.println("ScheduledThreadPool terminated: " + scheduledThreadPool.isTerminated());
        System.out.println("SingleThreadExecutor terminated: " + singleThreadExecutor.isTerminated());
    }
}