Java多线程编程与线程池深度解析

昔年忆2024-04-11 17:12

​

第一部分：Java多线程基础

1.1 创建线程的方式

Java提供了两种主要的创建线程的方式：继承Thread类和实现Runnable接口。此外，还可以通过实现Callable接口实现线程，并在主线程获取返回值。

继承Thread类：

typescript 复制代码 
class MyThread extends Thread {
    public void run() {
        // 线程执行的任务
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

实现Runnable接口：

typescript 复制代码 
class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的任务
    }
}

public class Main {
    public static void main(String[] args) {
        Thread myThread = new Thread(new MyRunnable());
        myThread.start();
    }
}

实现Callable接口：

java 复制代码 
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable<String> {
    public String call() throws Exception {
        // 线程执行的任务，并返回结果
        return "Task completed!";
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建Callable任务
        Callable<String> myCallable = new MyCallable();
        // 将Callable任务封装为FutureTask
        FutureTask<String> futureTask = new FutureTask<>(myCallable);

        // 创建线程并启动
        Thread thread = new Thread(futureTask);
        thread.start();

        try {
            // 获取线程执行结果
            String result = futureTask.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

为什么要使用实现Runnable接口和实现Callable接口的方式？因为Java是单继承的，如果已经继承了其他类，就无法再继承Thread类，但可以实现Runnable接口或实现Callable接口，从而更灵活地组织代码结构。

1.2 线程的同步与互斥

在多线程环境中，为了确保共享资源的安全访问，需要使用synchronized关键字实现线程的同步与互斥。

同步方法：

arduino 复制代码 
class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }
}

同步代码块：

csharp 复制代码 
class Counter {
    private int count = 0;

    public void increment() {
        synchronized (this) {
            count++;
        }
    }
}

通过synchronized关键字，可以确保同一时刻只有一个线程访问共享资源，避免数据不一致的问题。

1.3 线程间通信

在多线程编程中，线程之间可能需要进行通信。Java提供了wait、notify和notifyAll等方法来实现线程间的协作。

生产者-消费者模型：

java 复制代码 
class SharedResource {
    private boolean flag = false;

    public synchronized void produce() throws InterruptedException {
        while (flag) {
            wait();
        }
        // 生产操作
        flag = true;
        notify();
    }

    public synchronized void consume() throws InterruptedException {
        while (!flag) {
            wait();
        }
        // 消费操作
        flag = false;
        notify();
    }
}

在这个例子中，生产者线程通过produce方法向共享资源添加数据，而消费者线程通过consume方法从共享资源消费数据。通过使用wait和notify，实现了线程之间的协同工作。

第二部分：Java线程池

2.1 Java内置线程池

Java提供了Executors工厂类，用于创建各种类型的线程池。以下是一个使用FixedThreadPool的示例：

java 复制代码 
import java.util.concurrent.*;

class MyTask implements Runnable {
    public void run() {
        // 线程执行的任务
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);
        // 提交任务
        executor.submit(new MyTask());
        // 关闭线程池
        executor.shutdown();
    }
}

2.2 使用alibaba推荐的线程池方式

Alibaba推荐使用ThreadPoolExecutor的构造方法创建线程池，以提供更精细的参数配置。

java 复制代码 
import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            5, // corePoolSize
            10, // maximumPoolSize
            60, // keepAliveTime
            TimeUnit.SECONDS, // unit
            new LinkedBlockingQueue<>(100), // workQueue
            new ThreadPoolExecutor.CallerRunsPolicy() // handler
        );

        // 提交任务
        executor.submit(new MyTask());

        // 关闭线程池
        executor.shutdown();
    }
}

这里使用了ThreadPoolExecutor.CallerRunsPolicy作为拒绝策略，表示由调用线程（主线程）执行被拒绝的任务。

2.3 线程池的核心参数与配置

线程池的核心参数包括corePoolSize、maximumPoolSize、keepAliveTime、unit和workQueue。这些参数决定了线程池的基本特性和行为。

  • corePoolSize：核心线程数，即线程池维护的最小线程数。

  • maximumPoolSize：最大线程数，即线程池允许创建的最大线程数。

  • keepAliveTime ：线程空闲时间，即当线程池中线程数量超过corePoolSize时，多余的空闲线程在被终止之前等待新任务的最长时间。

  • unit ：时间单位，用于指定keepAliveTime的时间单位。

  • workQueue：工作队列，用于保存等待执行的任务。

2.4线程池执行流程​​

  • 具体来说，线程池的行为如下：

  • 当任务数量超过核心线程数 (corePoolSize) 时，新任务会被放入工作队列 (workQueue)。

  • 如果工作队列已满，且当前线程数量小于最大线程数 (maximumPoolSize)，则会创建新的非核心线程来处理任务。

  • 如果工作队列已满，且当前线程数量达到最大线程数，此时新任务无法处理，会触发线程池的拒绝策略。

  • 对于非核心线程，在它们处于闲置状态时，会根据 keepAliveTime 的设置，在超过这个时间后被回收。

以下是一个线程池的配置示例：

java 复制代码 
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, // corePoolSize
    10, // maximumPoolSize
    60, // keepAliveTime
    TimeUnit.SECONDS, // unit
    new LinkedBlockingQueue<>(100) // workQueue
);

参数选择的注意事项：

  • corePoolSize 的选择应该考虑系统资源和并发任务的性质。
  • maximumPoolSize 的选择应该足够大，以处理可能的突发任务。
  • keepAliveTime 的选择应该根据任务执行时间的长短和系统资源的可用性来确定。
  • workQueue 的选择应该根据任务的性质来确定，例如，对于耗时短、频繁的任务，可以选择一个无界队列，对于耗时长的任务，可以选择一个有界队列。

2.5 线程池的使用

使用线程池可以通过submit方法提交任务，并通过Future对象获取执行结果。在任务执行完毕后，记得调用shutdown方法关闭线程池。

java 复制代码 
import java.util.concurrent.*;

class MyTask implements Callable<String> {
    public String call() throws Exception {
        // 线程执行的任务，并返回结果
        return "Task completed!";
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);
        try {
            // 提交任务
            Future<String> future = executor.submit(new MyTask());
            // 获取执行结果
            String result = future.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            executor.shutdown();
        }
    }
}

2.6 线程池的异常处理和关闭

线程池的异常处理可以通过setRejectedExecutionHandler方法进行设置，用于处理任务被拒绝执行的情况。在任务执行完毕后，要记得调用shutdown方法关闭线程池。

ini 复制代码 
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    // ...
);
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.shutdown();

第三部分：实战与最佳实践

3.1 抢红包实例

在实际应用中，线程池和多线程编程可以用于模拟一些有趣的场景，比如多人同时抢红包。

java 复制代码 
import java.util.concurrent.*;

class RedPacketTask implements Callable<String> {
    private static int totalAmount = 1000;

    public String call() throws Exception {
        synchronized (RedPacketTask.class) {
            if (totalAmount > 0) {
                // 抢红包逻辑
                System.out.println(Thread.currentThread().getName() + " 抢到红包");
                totalAmount -= 10;
                return "抢到红包";
            } else {
                return "红包已抢完";
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        try {
            for (int i = 0; i < 10; i++) {
                Future<String> future = executor.submit(new RedPacketTask());
                System.out.println(future.get()); // 获取执行结果
            }
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}
arduino 复制代码 
synchronized (RedPacketTask.class) {
    // ...
}

这里使用的锁定对象是 RedPacketTask.class，而不是具体的 RedPacketTask 实例。这是因为synchronized关键字可以用于不同对象的同步块，只要这些块使用相同的锁。

对于这个具体的例子，RedPacketTask.class 是一个类的 Class 对象，是在类加载时由 Java 虚拟机自动创建的，且在整个应用程序的生命周期中只有一个。因此，通过使用类的 Class 对象作为锁，你确保了对于所有 RedPacketTask 类的实例都使用相同的锁。

这样做的好处是，不同的 RedPacketTask 实例共享同一个锁，确保在同一时刻只有一个线程能够执行同步块中的代码。这是一种广义的锁，适用于类级别的同步。

3.2 工厂模拟实例

另一个例子是模拟工厂中多个工人同时工作的场景。

arduino 复制代码 
import java.util.concurrent.*;

class Worker implements Callable<String> {
    private String name;

    public Worker(String name) {
        this.name = name;
    }

    public String call() throws Exception {
        System.out.println(name + " 开始工作");
        // 工作逻辑
        System.out.println(name + " 完成工作");
        return name + " 工作完成";
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        try {
            List<Future<String>> futures = new ArrayList<>();
            for (int i = 1; i <= 5; i++) {
                futures.add(executor.submit(new Worker("工人" + i)));
            }

            for (Future<String> future : futures) {
                System.out.println(future.get()); // 获取执行结果
            }
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

​

相关推荐
先做个垃圾出来………2 分钟前
差分数组（Difference Array）
java·数据结构·算法
库库林_沙琪马15 分钟前
REST接口幂等设计深度解析
spring boot·后端
BillKu18 分钟前
Java核心概念详解：JVM、JRE、JDK、Java SE、Java EE (Jakarta EE)
java·jvm·jdk·java ee·jre·java se·jakarta ee
IT_陈寒18 分钟前
Redis性能提升50%的7个关键优化策略，90%开发者都不知道第5点！
前端·人工智能·后端
智商偏低23 分钟前
ASP.NET Core 身份验证概述
后端·asp.net
冷冷的菜哥23 分钟前
ASP.NET Core使用MailKit发送邮件
后端·c#·asp.net·发送邮件·mailkit
canonical_entropy41 分钟前
XDef：一种面向演化的元模型及其构造哲学
后端
小林coding1 小时前
再也不怕面试了！程序员 AI 面试练习神器终于上线了
前端·后端·面试
lypzcgf1 小时前
Coze源码分析-资源库-删除插件-后端源码-错误处理与总结
人工智能·后端·go·coze·coze源码分析·ai应用平台·agent平台
刘婉晴1 小时前
【Java】NIO 简单介绍
java·nio
热门推荐
01UV安装并设置国内源02A股预测还能更准？开源大模型Kronos带你跑通预测+回测全流程032025 年高教社杯全国大学生数学建模竞赛C 题 NIPT 的时点选择与胎儿的异常判定 完整成品思路模型代码分享，全网首发高质量！！！042025年数学建模国赛C题超详细解题思路05UV 工具安装与国内镜像源配置指南06不再让Windows更新！&Edge游戏助手卸载及关闭自动更新07KGG转MP3工具|非KGM文件|解密音频08突破百度网盘的下载限速，两种方法教会你【超详细】09Linux下V2Ray安装配置指南10教你如何认证 Gemini 教育优惠的二次验证，薅个 1年的 Gemini Pro 会员