JAVA多线程实现的四种方式及使用场景详解_Java

一、继承thread类实现多线程

步骤一：定义线程类
创建一个类继承自thread类，并重写run方法。run方法中的代码就是线程执行的内容。
例如：

class mythread extends thread {
    @override
    public void run() {
        for (int i = 0; i < 10; i++) {
            system.out.println("mythread: " + i);
        }
    }
}

步骤二：启动线程
在main方法或者其他合适的地方创建线程对象，然后调用start方法来启动线程。
例如：

public class main {
    public static void main(string[] args) {
        mythread thread = new mythread();
        thread.start();
        for (int i = 0; i < 10; i++) {
            system.out.println("main thread: " + i);
        }
    }
}

注意，不能直接调用run方法来启动线程。如果直接调用run方法，就相当于在当前线程中执行run方法中的代码，而不是开启一个新的线程。

二、实现runnable接口实现多线程

步骤一：定义任务类
创建一个类实现runnable接口，实现run方法。这个run方法包含了线程要执行的任务。
例如：

java
class myrunnable implements runnable {
    @override
    public void run() {
        for (int i = 0; i < 10; i++) {
            system.out.println("myrunnable: " + i);
        }
    }
}

步骤二：创建线程并启动
首先创建runnable对象，然后将其作为参数传递给thread对象的构造函数，最后调用thread对象的start方法来启动线程。
例如：

public class main {
    public static void main(string[] args) {
        myrunnable runnable = new myrunnable();
        thread thread = new thread(runnable);
        thread.start();
        for (int i = 0; i < 10; i++) {
            system.out.println("main thread: " + i);
        }
    }
}

实现runnable接口的优势
这种方式更灵活，因为一个类可以实现多个接口，避免了单继承的限制。例如，如果一个类已经继承了其他类，还想实现多线程功能，就可以使用实现runnable接口的方式。而且runnable对象可以被多个线程共享，方便在多个线程中执行相同的任务。

三、使用callable和future实现多线程（带有返回值）

步骤一：定义callable任务类
创建一个类实现callable接口，实现call方法。call方法中包含线程要执行的任务，并且可以有返回值。
例如：

import java.util.concurrent.callable;
class mycallable implements callable<integer> {
    @override
    public integer call() {
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            sum += i;
        }
        return sum;
    }
}

步骤二：提交任务并获取结果
通过executorservice来提交callable任务。executorservice可以通过executors工厂类来创建。
例如：

import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
import java.util.concurrent.future;
public class main {
    public static void main(string[] args) throws exception {
        executorservice executorservice = executors.newsinglethreadexecutor();
        mycallable callable = new mycallable();
        future<integer> future = executorservice.submit(callable);
        system.out.println("计算结果: " + future.get());
        executorservice.shutdown();
    }
}

在这里，submit方法提交callable任务并返回一个future对象，通过future对象的get方法可以获取callable任务的返回值。shutdown方法用于关闭executorservice。

四、线程池的使用（executorservice）

步骤一：创建线程池
可以使用executors工厂类创建不同类型的线程池，如newfixedthreadpool（固定大小线程池）、newcachedthreadpool（可缓存线程池）、newsinglethreadexecutor（单线程线程池）等。
例如，创建一个固定大小为 5 的线程池：

executorservice executorservice = executors.newfixedthreadpool(5);

步骤二：提交任务到线程池
可以使用execute方法提交runnable任务，或者使用submit方法提交callable任务到线程池。
例如，提交一个runnable任务：

class myrunnableinpool implements runnable {
    @override
    public void run() {
        system.out.println("线程池中的线程在执行任务");
    }
}
public class main {
    public static void main(string[] args) {
        executorservice executorservice = executors.newfixedthreadpool(5);
        for (int i = 0; i < 10; i++) {
            executorservice.execute(new myrunnableinpool());
        }
        executorservice.shutdown();
    }
}

步骤三：关闭线程池
当任务执行完毕后，需要关闭线程池。可以使用shutdown方法来正常关闭线程池，它会等待所有已提交的任务执行完毕后再关闭。如果想要立即关闭线程池，可以使用shutdownnow方法，但这种方式可能会导致正在执行的任务被中断。
例如：

executorservice.shutdown();

q：一个管理系统的java项目，什么时候会需要用到多线程呢？

1、数据导入与导出功能

背景和需求：
在管理系统中，经常需要进行数据的导入和导出操作。例如，将大量的用户信息、订单数据等从外部文件（如 csv、excel 文件）导入到数据库中，或者将系统中的数据导出为报表文件。这些操作可能涉及大量的数据处理，如果在单线程中执行，会导致界面长时间无响应，用户体验差。
多线程的应用方式：
可以开启一个单独的线程来执行数据导入或导出任务。这样，在数据处理的同时，用户界面仍然可以响应用户的其他操作，如查看其他数据、进行系统设置等。例如，当用户点击 “导入数据” 按钮时，系统在后台线程中读取文件、解析数据并插入到数据库，而前台线程继续响应用户的其他交互。

2、数据缓存更新与维护

背景和需求：
为了提高系统性能，管理系统通常会使用数据缓存。缓存的数据需要定期更新，以保证数据的一致性和时效性。例如，缓存的商品库存信息、用户权限信息等需要根据数据库中的最新数据进行更新。
多线程的应用方式：
可以使用一个线程定期（如每隔一段时间）检查缓存数据是否过期，并在需要时更新缓存。这个线程可以在后台默默地运行，不影响系统的其他主要功能。同时，在数据发生变化（如用户修改了商品库存）时，也可以通过多线程机制及时更新缓存，以减少对系统其他操作的影响。

3、并发用户操作处理

背景和需求：
在多用户使用的管理系统中，会有多个用户同时进行各种操作，如查询数据、修改记录、提交表单等。如果系统是单线程的，这些操作只能依次进行，效率低下。
多线程的应用方式：
为每个用户请求分配一个独立的线程来处理。例如，在一个在线商城管理系统中，当多个管理员同时修改商品价格、处理订单时，系统可以为每个管理员的操作开启一个线程，这些线程可以并发地访问和修改数据库中的数据（当然，需要注意数据库连接池的合理使用和数据的一致性问题），从而提高系统的并发处理能力。

4、系统监控与日志记录

背景和需求：
管理系统需要对自身的运行状态进行监控，如系统资源使用情况（cpu、内存、磁盘 i/o 等）、服务的可用性等。同时，需要记录用户操作日志、系统错误日志等信息。
多线程的应用方式：
可以使用一个线程专门负责系统监控，定期收集系统状态数据并进行分析。另一个线程可以负责将日志信息写入日志文件，这样可以避免日志记录操作阻塞其他业务操作，并且在系统出现问题时能够及时记录相关信息，方便后续的故障排查。

5、定时任务执行

背景和需求：
管理系统中有很多定时任务，如每天定时生成销售报表、每月定时结算员工工资等。这些任务需要在特定的时间自动执行，并且不能影响系统的正常运行。
多线程的应用方式：
通过线程池来管理定时任务线程。例如，使用 java 中的scheduledexecutorservice来安排定时任务。系统可以根据任务的执行时间和频率，在后台线程中自动执行这些任务，而不会干扰系统的日常操作。

q：只要继承了runnable接口，用这个类的时候就开启多线程了吗？

继承runnable接口只是定义了任务内容
当一个类实现了runnable接口，它仅仅是定义了一个线程要执行的任务逻辑，这个任务逻辑包含在run方法中。

例如：

class myrunnable implements runnable {
    @override
    public void run() {
        system.out.println("执行自定义任务");
    }
}

上述代码定义了一个名为myrunnable的类，它实现了runnable接口，run方法里是具体要执行的任务。但此时，只是定义了任务，还没有开启多线程。

需要通过thread类来启动线程执行任务

要真正开启一个新的线程来执行这个任务，需要将runnable对象作为参数传递给thread类的构造函数，然后调用thread对象的start方法。例如：

java
public class main {
    public static void main(string[] args) {
        myrunnable runnable = new myrunnable();
        thread thread = new thread(runnable);
        thread.start();
    }
}

在这个例子中，首先创建了myrunnable类的一个对象runnable，然后通过new thread(runnable)创建了一个thread对象，这个thread对象将执行runnable对象中定义的任务。最后，调用thread.start()方法来启动线程。如果只是创建了

thread对象而没有调用start方法，任务也不会在新的线程中执行，和普通方法调用没有区别。

所以，仅仅继承runnable接口并没有开启多线程，它只是提供了一种方便的方式来定义线程要执行的任务，还需要通过thread类来实际启动线程，让任务在新的线程环境中运行。