JavaSe多线程技术

 前言

此篇文章属于Java语言必学基础内容

文章目录

目录

一、什么是Java中的多线程技术？

二、创建多线程的七种方式

​编辑

1. 继承Thread类创建编程

2.第二第三第四条可以简写通过新特性：

3.使用callable和Future创建线程：

4.使用线程池Executor框架：

---

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、什么是Java中的多线程技术？

多线程技术是指在一个程序中同时运行多个线程（也可以理解为多个独立的任务），并且这些线程可以并行执行，从而提高程序的效率和性能。在多线程技术中，每个线程都有自己的代码执行路径、堆栈和局部变量等，但是它们共享进程的地址空间和全局变量等资源。

多线程技术的应用广泛，例如：

1. 在操作系统中，多线程技术可以用于实现任务调度、I/O操作、网络通信等。

2. 在图形界面程序中，多线程技术可以用于实现用户界面响应和数据更新等。

3. 在游戏开发中，多线程技术可以用于实现物理模拟、AI计算、碰撞检测等。

4. 在服务器开发中，多线程技术可以用于实现并发请求处理、数据库操作等。

需要注意的是，多线程技术也存在一些问题，例如线程安全、死锁、资源竞争等，需要开发人员加以注意和解决。

二、创建多线程的七种方式

 注意：

1.  使用Callable和Future创建线程的优点是可以获取线程的结果，并且可以对线程进行控制和管理，例如取消任务的执行、设置超时等。

2.  使用线程池是通过复用机制

1. 继承Thread类创建编程

需要注意，线程与线程之间没有不相互影响。

public class Thread01 extends Thread {

    @Override
    public void run() {
        System.out.println(Thread.currentThread()+"<我是子线程>");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread()+"<阻塞完毕>");
    }

    public static void main(String[] args) {
        new Thread01().start();
        System.out.println("主线程main执行完毕！");
    }
}

运行结果：

2.第二第三第四条可以简写通过新特性：

public class Thread02{

    public static void main(String[] args) {
        new Thread(() -> System.out.println(Thread.currentThread()+"<我是子线程666>")).start();
    }
}

3.使用callable和Future创建线程：

在Java中，可以使用Callable接口和Future接口来创建线程。

首先，Callable接口代表了一个可调用的任务，它可以在线程中执行并返回一个结果。该接口定义了一个call()方法，你需要实现这个方法来执行具体的任务逻辑并返回结果。

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 执行任务逻辑
        return "Task completed";
    }
}

接着，使用ExecutorService来创建线程池并提交Callable任务。ExecutorService是Java提供的一个线程池框架，它可以管理线程的生命周期并执行任务。

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

public class Main {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        
        // 创建Callable任务
        MyCallable callable = new MyCallable();
        
        // 提交任务，并获取Future对象
        Future<String> future = executorService.submit(callable);
        
        // 执行其他操作
        
        try {
            // 阻塞并等待任务执行完成，并获取结果
            String result = future.get();
            
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        // 关闭线程池
        executorService.shutdown();
    }
}

4.使用线程池Executor框架：

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

public class Main {
    public static void main(String[] args) {
        // 创建固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        
        for (int i = 0; i < 10; i++) {
            // 提交任务给线程池执行
            executorService.execute(new MyRunnable(i));
        }
        
        // 关闭线程池
        executorService.shutdown();
    }
}

class MyRunnable implements Runnable {
    private int taskId;

    public MyRunnable(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("Task " + taskId + " is executing.");
        // 执行具体的任务逻辑
        
        try {
            // 假设任务需要一些时间来完成
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Task " + taskId + " is completed.");
    }
}