Java多线程——线程池，全方面解答，小白收藏这篇也足够了

线程池

1.1 什么是线程池

线程池是一种多线程管理机制，通过池化技术来重用现有线程而不是创建新的线程，从而降低线程创建和销毁的开销。线程池通过工作队列和线程管理来实现高效的任务执行。

1.2 为什么使用线程池

一个线程大约占用的内存为1M

1. 解决频繁创建线程和销毁线程消耗的性能
2. 解决大量创建线程而导致的内存泄露问题

线程池的优点

降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的销毁

提高响应速度：当任务到达时，任务可以不需要等到线程创建就能立即执行

提高线程的可管理性

线程可以复用、可以控制最大并发数、可以管理线程

1.3 线程池的组成

线程池的关键组成部分包括：

1. 线程池管理器(ThreadPoolExecutor):负责创建、管理和控制线程池。
2. 工作队列：用于存储待执行的任务。
3. 线程池线程：实际执行任务的线程。线程池中会维护一组线程，这些线程可以被重复使用，从而避免了频繁创建和销毁的开销

1.4 如何创建线程池

Java提供了两种方式：

第一种：通过工具类完成线程池的创建【Executors】，语法简单，但是阿里巴巴不建议使用

第二种：通过线程池类【ThreadPoolExecutor】，语法复杂，但是阿里巴巴建议使用，灵活

线程的根接口：Executor，其中只有一个方法：execute。

线程的子接口：ExecutorService，其中方法有很多。

1.4.1 第一种方式–Executors工具类

① 固定大小线程池对象 newFixedThreadPool

1. 语法格式

   //创建一个固定大小的线程池，返回类型为ExecutorService
   ExecutorService executorService = Executors.newFixedThreadPool(5);
   
   

2. 介绍

   该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变，当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。

public class Test1 {
    public static void main(String[] args) {
        //创建一个固定大小的线程池，返回类型为ExecutorService
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 20; i++) {
            //调用execute方法，参数必须传递Runnable对象。
            //传递Runnable对象的三种方式
            //[1]自己创建一个类实现Runnable接口  [2]匿名内部类对象 [3]lambda表达式: 前提接口必须为函数式接口。
            executorService.execute(()-> System.out.println(Thread.currentThread().getName()+"--->"+i));
        }
    }
}

② 单一线程池 newSingleThreadExecutor

1. 语法

   //创建单一线程池，返回类型ExecutorService
   ExecutorService executorService = Executors.newSingleThreadExecutor();
   
   

2. 介绍

   该方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。

public class Test2 {
    public static void main(String[] args) {
        //创建单一线程池，返回类型ExecutorService
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 50; i++) {
            executorService.execute(()->
                                    System.out.println(Thread.currentThread().getName()+"==========="));
        }
    }
}

③ 可变线程池 newCachedThreadPool

1. 语法

   //创建可变大小的线程池，返回类型ExecutorService
   ExecutorService executorService = Executors.newCachedThreadPool();
   
   

2. 介绍

   该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。

public class Test3 {
    public static void main(String[] args) {
        //创建可变大小的线程池，返回类型ExecutorService
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 20; i++) {
            executorService.execute(()-> System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~"));
        }
    }
}

④ 延迟线程池 newScheduledThreadPool

1. 语法

   //创建延迟线程池，返回类型为ScheduledExecutorService
   ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
   
   

2. 介绍

   该方法返回的是一个支持定时及周期性的线程池。该线程池对象执行的不是excute方法，执行的是schedule方法。

   schedule方法中的三个参数为：

   • 传递Runnable对象或Callable对象
   • 设置多长时间后开始执行任务代码块
   • 设置时间单位

public class Test4 {
    public static void main(String[] args) {
        //创建延迟线程池，返回类型为ScheduledExecutorService
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        for (int i = 0; i < 20; i++) {
            //schedule方法，必须传递Callable对象
            scheduledExecutorService.schedule(
                ()->{ System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~"); }，
                5, //表示5秒后执行任务代码块
                TimeUnit.SECONDS
            );
        }
    }
}

亦或者执行scheduleAtFixedRate方法

其中包含四个参数为：

1. 传递Runnable对象或Callable对象
2. 设置多长时间后开始执行任务代码块
3. 设置每隔多长时间执行一次代码块
4. 设置时间单位

public class Test5 {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
        for (int i = 0; i < 5; i++) {
            //scheduleAtFixedRate:必须传递Runnable接口
            scheduledExecutorService.scheduleAtFixedRate(
                ()-> { System.out.println(Thread.currentThread().getName()+"~~~~~~~~~"); },//对象
                3, //3秒后执行任务
                2, //2秒执行一次
                TimeUnit.SECONDS //时间单位为秒
            );
        }
    }
}

1.4.2 Executors创建的线程池缺点

《阿里巴巴java开发手册》中强制线程池不允许使用Exexutors去创建，而是通过ThreadPoolExextor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险

Executors 返回线程池对象的弊端如下：
FixedThreadPool 和 SingleThreadExecutor ： 允许请求的队列长度为 Integer.MAX_VALUE,
										   可能堆积大量的请求，从而导致OOM。（Out Of Memory：内存用完了！）
CachedThreadPool 和 ScheduledThreadPool ： 允许创建的线程数量为 Integer.MAX_VALUE，
										   可能会创建大量线程，从而导致OOM。

1.4.3 线程池的七大参数

1. int corePoolSize：核心线程数量，不能小于0
2. int maximumPoolSize ：最大线程的线程数量，减去核心线程=临时线程
3. long keepAliveTime ：空闲线程的最大存活时间，没有人使用会自动释放
4. TimeUnit unit ：时间单位
5. BlockingQueue workQueue ：任务队列
6. ThreadFactory th：线程工厂，创建线程的，一般不用动
7. RejectedExecutionHandler handler ：任务的拒绝策略

1.4.4 第二种方式–ThreadPoolExecutor

① 语法介绍

1. 语法

   ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(参数列表);

2. 参数介绍

   • int corePoolSize：核心线程数的个数

   • int maximumPoolSize：最大线程数量

   • long keepAliveTime：非核心线程允许空闲的时间

   • TimeUnit unit：时间单位

   • BlockingQueue workQueue：堵塞队列

public class Test1 {
    public static void main(String[] args) {
        //创建任务队列
        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue(3);
        //创建线程池
        ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(2,6,6, TimeUnit.SECONDS,workQueue);
        for (int i = 0; i < 9; i++) {
            //调用submit方法，执行线程任务
            threadPoolExecutor.submit(()->{
                System.out.println(Thread.currentThread().getName()+"~~~~~~~~~");
            });
        }
    }
}

② 场景理解

我们可以通过下面的场景理解ThreadPoolExecutor中的各个参数;
a客户(任务)去银行(线程池)办理业务,但银行刚开始营业,窗口服务员还未就位(相当于线程池中初始线程数量为0),
于是经理(线程池管理者)就安排1号工作人员(创建1号线程执行任务)接待a客户(创建线程);
在a客户业务还没办完时,b客户(任务)又来了,于是经理(线程池管理者)就安排2号工作人员(创建2号线程执行任务)接待b客户(又创建了一个新的线程);假设该银行总共就2个窗口(核心线程数量是2);
紧接着在a,b客户都没有结束的情况下c客户来了,于是经理(线程池管理者)就安排c客户先坐到银行大厅的座位上(空位相当于是任务队列)等候,
并告知他: 如果1、2号工作人员空出,c就可以前去办理业务;
此时d客户又到了银行,(工作人员都在忙,大厅座位也满了)于是经理赶紧安排临时工(新创建的线程)在大堂站着,手持pad设备给d客户办理业务;
假如前面的业务都没有结束的时候e客户又来了,此时正式工作人员都上了,临时工也上了,座位也满了(临时工加正式员工的总数量就是最大线程数),
于是经理只能按《超出银行最大接待能力处理办法》(饱和处理机制)拒接接待e客户;
最后,进来办业务的人少了,大厅的临时工空闲时间也超过了1个小时(最大空闲时间),经理就会让这部分空闲的员工人下班.(销毁线程)
但是为了保证银行银行正常工作(有一个allowCoreThreadTimeout变量控制是否允许销毁核心线程,默认false),即使正式工闲着,也不得提前下班,所以1、2号工作人员继续待着(池内保持核心线程数量);

③ 图示解析

④ 案例——秒杀商品

综合案例-秒杀商品
案例介绍:
	假如某网上商城推出活动,新上架10部新手机免费送客户体验,要求所有参与活动的人员在规定的时间同时参与秒杀挣抢,假如有20人同时参与了该活动,请使用线程池模拟这个场景,保证前10人秒杀成功,后10人秒杀失败;
要求:
	1:使用线程池创建线程
	2:解决线程安全问题
思路提示:
	1:既然商品总数量是10个,那么我们可以在创建线程池的时候初始化线程数是10个及以下,设计线程池最大数量为10个;
	2:当某个线程执行完任务之后,可以让其他秒杀的人继续使用该线程参与秒杀;
	3:使用synchronized控制线程安全,防止出现错误数据;
代码步骤:
	1:编写任务类,主要是送出手机给秒杀成功的客户;
	2:编写主程序类,创建20个任务(模拟20个客户);
	3:创建线程池对象并接收20个任务,开始执行任务;
    主程序类,测试任务类

• 任务类

public class Goods implements Runnable{
    //定义一个变量，用于存储用户编号
    private String name;
    //有参构造方法，初始化用户编号
    public Goods(String name){
        this.name=name;
    }
    private static  int count=10;
    @Override
    public void run() {
            System.out.println(name+"进入了秒杀活动");
            if(count>0){
                synchronized (Goods.class){
                    System.out.println(name+"抢到了"+count+"号手机，秒杀成功！");
                    count--;
                }
            }else {
                System.out.println(name+"秒杀失败");
            }
    }
}

• 主任务类测试

public class Test {
    public static void main(String[] args) {
        //创建阻塞队列对象
        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue<>(5);
        //创建线程池
        ThreadPoolExecutor poolExecutor=new ThreadPoolExecutor(2,5,6, TimeUnit.SECONDS,workQueue);

        //循环20个用户
        for (int i = 1; i <=20; i++) {
            //创建任务对象
            Goods goods=new Goods("客户"+i);
            poolExecutor.submit(goods);
        }
    }
}

⑤ 线程池工作原理

1. 提交任务: 通过 execute(Runnable) 或 submit(Callable<T>) 方法提交任务。

2. 任务处理: 核心线程处理任务。如果核心线程已满，任务进入队列。如果队列已满且线程未达到最大线程数，创建新线程处理任

   ​ 务。如果达到最大线程数，执行拒绝策略。

3. 线程回收: 超过 keepAliveTime 的空闲线程会被终止，以节省资源。

1.4.5 任务队列（workQueue）

任务队列是基于阻塞队列实现的，即采用生产者消费者模式，在 Java 中需要实现 BlockingQueue 接口。但 Java 已经为我们提供了 7 种阻塞队列的实现：

① ArrayBlockingQueue

基于数组的有界队列。

import java.util.concurrent.*;

public class ArrayBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个容量为3的有界阻塞队列
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(3);

        // 添加元素到队列中
        queue.put(1);
        queue.put(2);
        queue.put(3);

        // 试图添加第四个元素时会阻塞，因为队列已满
        new Thread(() -> {
            try {
                queue.put(4);
                System.out.println("Added 4");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // 让主线程休眠一会儿，以确保子线程被阻塞
        Thread.sleep(2000);

        // 移除队列中的元素
        System.out.println("Removed: " + queue.take());
        System.out.println("Removed: " + queue.take());
        System.out.println("Removed: " + queue.take());

        // 现在队列有空间，子线程可以继续执行
    }
}

② LinkedBlockingQueue

基于链表的无界队列（或指定容量的有界队列）。在未指明容量时，容量默认为 Integer.MAX_VALUE。

import java.util.concurrent.*;

public class LinkedBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        // 未指定容量时，默认容量为 Integer.MAX_VALUE
        LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

        // 添加元素到队列中
        queue.put(1);
        queue.put(2);
        queue.put(3);

        // 移除并打印队列中的元素
        System.out.println("Removed: " + queue.take());
        System.out.println("Removed: " + queue.take());
        System.out.println("Removed: " + queue.take());
    }
}

③ PriorityBlockingQueue

基于优先级的无界队列，跟时间没有关系，对元素没有要求。可以实现 Comparable 接口也可以提供 Comparator 来对队列中的元素进行比较。

import java.util.concurrent.*;

public class PriorityBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>();

        // 添加元素到队列中
        queue.put(5);
        queue.put(1);
        queue.put(3);

        // 移除并打印队列中的元素，按优先级顺序
        System.out.println("Removed: " + queue.take()); // 1
        System.out.println("Removed: " + queue.take()); // 3
        System.out.println("Removed: " + queue.take()); // 5
    }
}

④ DelayQueue

类似于PriorityBlockingQueue，是二叉堆实现的无界优先级队列。要求元素都实现 Delayed 接口，通过执行时延从队列中提取任务，时间没到任务取不出来。

import java.util.concurrent.*;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class DelayQueueExample {
    public static void main(String[] args) throws InterruptedException {
        DelayQueue<DelayedElement> queue = new DelayQueue<>();

        // 添加延迟元素到队列中
        queue.put(new DelayedElement("Element1", 5));
        queue.put(new DelayedElement("Element2", 3));
        queue.put(new DelayedElement("Element3", 1));

        // 移除并打印队列中的元素，按延迟时间
        while (!queue.isEmpty()) {
            System.out.println("Removed: " + queue.take());
        }
    }
}

class DelayedElement implements Delayed {
    private final String name;
    private final long startTime;

    public DelayedElement(String name, long delayInSeconds) {
        this.name = name;
        this.startTime = System.currentTimeMillis() + delayInSeconds * 1000;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        long diff = startTime - System.currentTimeMillis();
        return unit.convert(diff, TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        if (this.startTime < ((DelayedElement) o).startTime) {
            return -1;
        }
        if (this.startTime > ((DelayedElement) o).startTime) {
            return 1;
        }
        return 0;
    }

    @Override
    public String toString() {
        return name;
    }
}

⑤ SynchronousQueue

不存储任务的队列，每个插入操作必须等待相应的删除操作。

import java.util.concurrent.*;

public class SynchronousQueueExample {
    public static void main(String[] args) {
        SynchronousQueue<Integer> queue = new SynchronousQueue<>();

        // 创建消费者线程
        new Thread(() -> {
            try {
                System.out.println("Consumed: " + queue.take());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // 创建生产者线程
        new Thread(() -> {
            try {
                queue.put(1);
                System.out.println("Produced: 1");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

⑥ LinkedBlockingDeque

使用双向队列实现的有界双端阻塞队列。双端意味着可以像普通队列一样 FIFO（先进先出），也可以像栈一样 FILO（先进后出）。

import java.util.concurrent.*;

public class LinkedBlockingDequeExample {
    public static void main(String[] args) throws InterruptedException {
        LinkedBlockingDeque<Integer> deque = new LinkedBlockingDeque<>(3);

        // 添加元素到双端队列
        deque.putFirst(1);
        deque.putLast(2);
        deque.putFirst(3);

        // 从双端队列移除元素
        System.out.println("Removed: " + deque.takeFirst());
        System.out.println("Removed: " + deque.takeLast());
        System.out.println("Removed: " + deque.takeFirst());
    }
}

⑦ LinkedTransferQueue

它是ConcurrentLinkedQueue、LinkedBlockingQueue 和 SynchronousQueue 的结合体，但是把它用在 ThreadPoolExecutor 中，和 LinkedBlockingQueue 行为一致，但是无界的阻塞队列。

import java.util.concurrent.*;

public class LinkedTransferQueueExample {
    public static void main(String[] args) {
        LinkedTransferQueue<Integer> queue = new LinkedTransferQueue<>();

        // 创建消费者线程
        new Thread(() -> {
            try {
                System.out.println("Consumed: " + queue.take());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // 创建生产者线程
        new Thread(() -> {
            try {
                queue.transfer(1);
                System.out.println("Produced and transferred: 1");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

有界队列和无界队列的区别：

​ 如果使用有界队列，当队列饱和时并超过最大线程数时就会执行拒绝策略；而如果使用无界队列，因为任务队列永远都可以添加任务，所以设置 maximumPoolSize 没有任何意义。

1.4.6 拒绝策略（handler）

当线程池的线程数达到最大线程数时，需要执行拒绝策略。

拒绝策略需要实现 RejectedExecutionHandler 接口，并实现 rejectedExecution(Runnable r, ThreadPoolExecutor e) 方法。

Executors 框架为我们实现了 4 种拒绝策略：

1. AbortPolicy: 直接抛出 RejectedExecutionException 异常。

   RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
   
   

2. CallerRunsPolicy: 由提交任务的线程处理该任务。

3. DiscardPolicy: 丢弃无法处理的任务，不抛出异常。

4. DiscardOldestPolicy: 丢弃队列中最旧的未处理任务，并尝试重新提交当前任务。

1.5 面试题

execute和submit方法区别？

**相同点：**两个方法都可以向线程池提交任务

**不同点：**execute()方法的返回类型是void，定义在Executor接口中，只能执行Runnable类型的任务

​ submit()方法可以返回持有计算结果的Future对象，定义在ExecutorService接口中，它扩展了Executor接口，可以执行runnable和callable类型的任务，其它线程池类像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有这些方法 。

---

说真的，这两年看着身边一个个搞Java、C++、前端、数据、架构的开始卷大模型，挺唏嘘的。大家最开始都是写接口、搞Spring Boot、连数据库、配Redis，稳稳当当过日子。

Java真的没有发展吗

学习Java并非真的没有退路，相反，如果将Java与现在热门的大模型结合会碰撞出不一样的火花

大模型技术正在为Java开发者开辟新赛道

1、推理环节的核心语言

• 大模型训练依赖Python生态的高性能计算资源，但推理阶段更注重模型部署、性能优化和系统集成。Java凭借其稳定性、跨平台特性和生态优势，成为推理环节的理想选择。例如，通过DJL（Deep Java Library）直接加载和使用预训练模型，无需深入底层Python代码。

2、工程化落地的关键角色

• 大模型从实验室到产业级应用的过程中，工程化能力成为核心竞争力。Java开发者在代码规范、测试流程、版本管理等方面的积累，能大幅降低大模型项目的研发成本。例如，利用Spring Cloud Gateway实现大模型调用的网关，进行请求限流、熔断降级和日志追踪。

3、多场景应用的桥梁

• Java在大模型工程化中承担关键职责：
  • 数据处理层：通过Apache PDFBox、Spring Batch等工具解析非结构化数据，实现知识库的向量化处理。
  • 检索服务层：调用大模型的Embedding API生成向量数据，并通过向量数据库（如Milvus）进行相似度匹配。
  • 模型调用层：通过适配器模式封装不同大模型的调用接口，实现“一键切换”。
    应用服务层：基于Spring Boot构建RESTful API，灵活编排“检索-生成”链路。

---

因此捕获AI，掌握技术是关键，让AI成为我们最便利的工具.

一定要把现有的技术和大模型结合起来，而不是抛弃你们现有技术！掌握AI能力的Java工程师比纯Java岗要吃香的多。

即使现在裁员、降薪、团队解散的比比皆是……但后续的趋势一定是AI应用落地！大模型方向才是实现职业升级、提升薪资待遇的绝佳机遇！

如何学习AGI大模型？

作为一名热心肠的互联网老兵，我决定把宝贵的AI知识分享给大家。 至于能学习到多少就看你的学习毅力和能力了 。我已将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

2025最新版优快云大礼包：《AGI大模型学习资源包》免费分享**

一、2025最新大模型学习路线

一个明确的学习路线可以帮助新人了解从哪里开始，按照什么顺序学习，以及需要掌握哪些知识点。大模型领域涉及的知识点非常广泛，没有明确的学习路线可能会导致新人感到迷茫，不知道应该专注于哪些内容。

我们把学习路线分成L1到L4四个阶段，一步步带你从入门到进阶，从理论到实战。

L1级别:AI大模型时代的华丽登场

L1阶段：我们会去了解大模型的基础知识，以及大模型在各个行业的应用和分析；学习理解大模型的核心原理，关键技术，以及大模型应用场景；通过理论原理结合多个项目实战，从提示工程基础到提示工程进阶，掌握Prompt提示工程。

L2级别：AI大模型RAG应用开发工程

L2阶段是我们的AI大模型RAG应用开发工程，我们会去学习RAG检索增强生成：包括Naive RAG、Advanced-RAG以及RAG性能评估，还有GraphRAG在内的多个RAG热门项目的分析。

L3级别：大模型Agent应用架构进阶实践

L3阶段：大模型Agent应用架构进阶实现，我们会去学习LangChain、 LIamaIndex框架，也会学习到AutoGPT、 MetaGPT等多Agent系统，打造我们自己的Agent智能体；同时还可以学习到包括Coze、Dify在内的可视化工具的使用。

L4级别：大模型微调与私有化部署

L4阶段：大模型的微调和私有化部署，我们会更加深入的探讨Transformer架构，学习大模型的微调技术，利用DeepSpeed、Lamam Factory等工具快速进行模型微调；并通过Ollama、vLLM等推理部署框架，实现模型的快速部署。

整个大模型学习路线L1主要是对大模型的理论基础、生态以及提示词他的一个学习掌握；而L3 L4更多的是通过项目实战来掌握大模型的应用开发，针对以上大模型的学习路线我们也整理了对应的学习视频教程，和配套的学习资料。

二、大模型经典PDF书籍

书籍和学习文档资料是学习大模型过程中必不可少的，我们精选了一系列深入探讨大模型技术的书籍和学习文档，它们由领域内的顶尖专家撰写，内容全面、深入、详尽，为你学习大模型提供坚实的理论基础。（书籍含电子版PDF）

三、大模型视频教程

对于很多自学或者没有基础的同学来说，书籍这些纯文字类的学习教材会觉得比较晦涩难以理解，因此，我们提供了丰富的大模型视频教程，以动态、形象的方式展示技术概念，帮助你更快、更轻松地掌握核心知识。

四、大模型项目实战

学以致用 ，当你的理论知识积累到一定程度，就需要通过项目实战，在实际操作中检验和巩固你所学到的知识，同时为你找工作和职业发展打下坚实的基础。

五、大模型面试题

面试不仅是技术的较量，更需要充分的准备。

在你已经掌握了大模型技术之后，就需要开始准备面试，我们将提供精心整理的大模型面试题库，涵盖当前面试中可能遇到的各种技术问题，让你在面试中游刃有余。

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

2025最新版优快云大礼包：《AGI大模型学习资源包》免费分享