
# 博客标题

这是文章的正文内容。你可以使用 Markdown 格式来编写内容。

## 小标题

段落文本可以**加粗**，*斜体*，或者`代码片段`。

### 代码示例

```javascript
// 这里可以插入代码示例
function hello() {
  console.log("Hello, world!");
}
```

### 列表

无序列表:

- 项目 1
- 项目 2
- 项目 3

有序列表:

1. 第一步
2. 第二步
3. 第三步

### 图片

![图片描述](/images/example.jpg)

### 链接

[链接文本](https://example.com)

### 引用

> 这是一个引用块。引用块可以用来突出显示重要信息或引用他人的话。

## 结语

总结你的文章，提出下一步行动或者进一步阅读的建议。

---

## 元数据字段说明

在每篇博客文章的顶部，你需要包含以下元数据（frontmatter）：

- **title**: 文章标题（必填）
- **excerpt**: 文章摘要，显示在列表页（建议填写）
- **date**: 发布日期（必填，格式为ISO格式）
- **author**: 作者名称（可选）
- **coverImage**: 封面图片路径（可选，如不提供会生成随机图片）
- **tags**: 文章标签，用于分类和筛选（可选，数组形式）
- **category**: 文章主分类（可选）
- **featured**: 是否为精选文章（可选，布尔值）

---

**注意**: 这个模板文件仅作为参考，不会显示在你的博客中。创建新文章时，复制此文件并重命名为你的文章标题（英文，用连字符连接），例如 `my-new-blog-post.md`。


博客标题 - 这里写文章的主标题


# 人工智能的最新进展与应用

人工智能（AI）正以前所未有的速度发展，不断突破技术边界并改变着我们的世界。本文将探讨AI领域的最新进展、实际应用以及未来可能的发展方向。

## 大型语言模型的突破

大型语言模型（LLMs）是近年来AI领域最令人瞩目的突破之一。这些模型通过处理海量文本数据，能够生成连贯、自然且信息丰富的文本内容。

### GPT系列模型

GPT（Generative Pre-trained Transformer）系列模型展示了令人印象深刻的语言理解和生成能力：

```
GPT-3: 1750亿参数
GPT-4: 参数规模未公开，但性能显著提升
```

这些模型已经能够：
- 撰写内容丰富的文章和报告
- 回答复杂问题并提供详细解释
- 翻译多种语言
- 生成创意内容，如故事和诗歌
- 编写和调试代码

### 多模态模型

最新的AI模型正在打破只懂文字的限制，发展为能同时理解和生成多种形式信息的系统：

- **图像理解与生成**：DALL-E、Midjourney和Stable Diffusion等模型能根据文字描述生成高质量图像
- **视频生成**：新兴的视频生成模型可以从文本描述创建短视频
- **音频处理**：语音识别和合成技术达到了接近人类水平的质量

## AI在各行业的实际应用

人工智能已经从实验室走向实际应用，在众多行业产生深远影响。

### 医疗健康

AI在医疗领域的应用正在改变疾病诊断和治疗方式：

- **医学影像分析**：AI系统能以高精度检测X光片、CT和MRI扫描中的异常
- **药物研发**：AI加速了新药的发现和开发过程
- **个性化医疗**：基于患者数据的AI模型能提供更精准的治疗方案

### 金融服务

金融行业正在利用AI提高效率和安全性：

- **风险评估**：AI模型能更准确地评估贷款风险
- **欺诈检测**：实时检测可疑交易，减少金融欺诈
- **算法交易**：利用AI预测市场走势并执行交易

### 教育

AI正在改变教育模式和学习体验：

- **个性化学习**：根据学生能力和进度定制课程内容
- **自动评分系统**：减轻教师工作负担
- **智能辅导系统**：提供24/7的学习支持

## AI发展面临的挑战

尽管AI取得了显著进步，但仍面临一系列挑战：

### 伦理与隐私问题

随着AI技术的广泛应用，伦理和隐私问题日益突出：

- **数据隐私**：AI系统需要大量数据训练，如何保护个人隐私？
- **决策透明度**：如何确保AI决策过程的透明性和可解释性？
- **偏见与歧视**：如何防止AI系统继承或放大训练数据中的社会偏见？

### 技术挑战

AI技术本身仍需克服多项技术难题：

- **能耗问题**：大型AI模型的训练和运行需要大量计算资源和能源
- **泛化能力**：如何提高AI系统在新环境和新任务中的适应能力？
- **因果推理**：从相关性到因果关系的推理仍是AI的难点

## AI的未来发展方向

展望未来，AI技术有望在以下方向取得突破：

### AGI（通用人工智能）的探索

研究者正致力于开发具有类似人类通用智能的系统，能够：
- 理解和学习任何智力任务
- 迁移学习能力到全新领域
- 展现出创造性思维

### 边缘AI与分布式智能

将AI能力下放到终端设备，减少对云计算的依赖：
- 提高实时性能
- 增强隐私保护
- 降低能源消耗

### 人机协作新模式

未来AI将更多作为人类的助手和伙伴，而非替代者：
- 增强人类能力
- 处理重复性任务
- 辅助创造性工作

## 结语

人工智能正处于蓬勃发展的时代，其影响力将继续扩大。面对这一技术变革，我们需要在推动创新的同时，也要重视技术发展带来的社会、伦理和经济影响，确保AI技术服务于人类福祉，创造更美好的未来。

对AI感兴趣的读者，可以通过学习机器学习基础知识、参与开源AI项目、关注顶级AI研究机构的最新发布等方式，深入了解这一快速发展的领域。


人工智能的最新进展与应用

设计模式学习记录

# 1. `ThreadPoolExcecutor`初始化

```java
ThreadPoolExecutor(int corePoolSize,
                    int maximumPoolSize,
                    long keepAliveTime,
                    TimeUnit unit,
                    BlockingQueue<Runnable> workQueue,
                    ThreadFactory threadFactory, //线程工厂，默认为DefaultThreadFactory
                    RejectedExecutionHandler handler //拒绝执行处理器-默认为AbortPolicy
                    )
                    

```

## 1.1 基本参数

```java
corePoolSize: 核心线程数，线程池中线程回收的下限，当线程池中的线程数量在核心线程数以内，则即使
	线程处于空闲也不会回收。
maximumPoolSize： 线程池的最大线程数。线程池最多只能创建这么多线程，ThreadPoolExecutor会根据corePoolSize和 
  maximumPoolSize自动线程池的参数。该参数也提供了相应的修改器方法去修改
keepAliveTime/unit: 配置空闲线程保活时间，如果线程池的线程数大于核心线程数且线程的空闲时间超过这个时间以后，则回收该线程。如果allowCoreThreadTimeOut
	为true，那么核心线程也会被超时回收。
	
/**
 * If false (default), core threads stay alive even when idle.
 * If true, core threads use keepAliveTime to time out waiting
 * for work.
 */
private volatile boolean allowCoreThreadTimeOut;
```

## 1.2 workQueue

- 任务队列，新提交的任务还没执行时会在该任务队列中排队等待。

**任务队列类型**

- **`ArrayBlockingQueue`**
    - **特点**：有界阻塞队列，使用数组实现。
    - **适用场景**：适用于对任务数量有严格限制的场景，能有效控制内存使用。
    - **优点**：防止内存溢出，适合**生产者和消费者速率大致相当**的情况。可以控制队列的大小。
- **`LinkedBlockingQueue`**
    - **特点**：可选择有界或无界的阻塞队列，使用链表实现。
    - **适用场景**：适合任务数量不确定的场合，尤其是任务产生速率远大于消费速率时。
    - **优点**：无界时可以动态扩展，适合处理大量任务。
- **`SynchronousQueue` -直接交接**
    - **特点**：不存储任务的队列，每个插入操作必须等待另一个线程的对应移除操作。
    - **适用场景**：适合需要快速交换任务的场景，例如短小的计算任务。
    - **优点**：可以充分利用 CPU，适合高并发场景。
- **`PriorityBlockingQueue`**
    - **特点**：无界的阻塞队列，支持优先级排序。
    - **适用场景**：需要根据任务优先级处理任务的情况。
    - **优点**：可以灵活处理不同优先级的任务。

**选择因素**

- **任务特性**
    - 任务的生产和消费速率：如果生产速率远高于消费速率，可能需要使用无界队列（如 `LinkedBlockingQueue`）。
    - 任务的处理时间：短小任务适合 `SynchronousQueue`，长时间运行的任务可能适合有界队列以控制队列大小。
- **内存管理**
    - 选择有界队列（如 `ArrayBlockingQueue` 或 `LinkedBlockingQueue`）可以防止内存溢出，特别是在高负载情况下。
- **线程池配置**
    - 如果线程池的核心线程数较小，**使用无界队列可以防止任务被拒绝，反之则可以使用有界队列以控制并发任务数量。**
- **优先级需求**
    - 如果需要根据任务优先级处理，可以选择 `PriorityBlockingQueue`。

## 1.3 threadFactory

- 线程池创建工作者的线程时，使用的工厂类。

```java
public interface ThreadFactory {

    /**
     * Constructs a new {@code Thread}.  Implementations may also initialize
     * priority, name, daemon status, {@code ThreadGroup}, etc.
     *
     * @param r a runnable to be executed by new thread instance
     * @return constructed thread, or {@code null} if the request to
     *         create a thread is rejected
     */
    Thread newThread(Runnable r);
}
```

## 1.4 handler

- 当线程提交到线程池，但因为运行的线程已到达最大线程数且任务队列已满或者其他原因无法执行时的处理策略。

```java
public interface RejectedExecutionHandler {

    /**
     * Method that may be invoked by a {@link ThreadPoolExecutor} when
     * {@link ThreadPoolExecutor#execute execute} cannot accept a
     * task.  This may occur when no more threads or queue slots are
     * available because their bounds would be exceeded, or upon
     * shutdown of the Executor.
     *
     * <p>In the absence of other alternatives, the method may throw
     * an unchecked {@link RejectedExecutionException}, which will be
     * propagated to the caller of {@code execute}.
     *
     * @param r the runnable task requested to be executed
     * @param executor the executor attempting to execute this task
     * @throws RejectedExecutionException if there is no remedy
     */
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

```

## 2. 工作者线程的创建逻辑

<aside>
💡

线程池创建之后，创建线程有2种方式，一种是线程池创建了之后，预启动线程，另一种是当线程池接收到任务之后，才去创建线程执行任务。

</aside>

1. 预启动线程
    
    场景：创建线程池时，任务队列已经有任务。
    
    ```java
    
    //该方法的逻辑为，如果当前线程池中运行的线程数小于核心线程数，则创建一个新的工作者线程加入池中
    public boolean prestartCoreThread() {
    	return workerCountOf(ctl.get()) < corePoolSize &&
    	    addWorker(null, true);
    }
    
    //该方法的逻辑同上，不同的地方是如果池中运行的线程为0，则创建一个新的工作者线程，无论核心线程数
    //配置的是多少。保证了最少有一个线程预启动了。
    void ensurePrestart() {
      int wc = workerCountOf(ctl.get());
      if (wc < corePoolSize)
          addWorker(null, true);
      else if (wc == 0)
          addWorker(null, false);
    }
    
    //预启动所有的所有的核心线程
    public int prestartAllCoreThreads() {
      int n = 0;
      while (addWorker(null, true))
          ++n;
      return n;
    }
    ```
    
2. 任务提交时，创建线程
    
    场景： 使用submit或者execute方法提交任务时
    
    1. 任务提交时，如果当前运行的线程数量少于配置的核心线程数，则创建新的工作者线程，并启动运行该任务，无论当前池中的已有的线程是否有空闲的。

# 3. 任务执行的逻辑

<aside>
💡

任务的提交可以使用submit或execute。提交了之后运行的主要逻辑如下：

```java
/*
 * Proceed in 3 steps:
 *
 * 1. If fewer than corePoolSize threads are running, try to
 * start a new thread with the given command as its first
 * task.  The call to addWorker atomically checks runState and
 * workerCount, and so prevents false alarms that would add
 * threads when it shouldn't, by returning false.
 *
 * 2. If a task can be successfully queued, then we still need
 * to double-check whether we should have added a thread
 * (because existing ones died since last checking) or that
 * the pool shut down since entry into this method. So we
 * recheck state and if necessary roll back the enqueuing if
 * stopped, or start a new thread if there are none.
 *
 * 3. If we cannot queue task, then we try to add a new
 * thread.  If it fails, we know we are shut down or saturated
 * and so reject the task.
 */
```

</aside>

如果还可以再创建线程，就创建新的线程执行任务，负责就加入到任务队列排队,工作者线程轮询去获取任务执行。如果既不能创建工作者线程执行，队列也满了，就拒绝任务（使用饱和策略来处理任务）。

# 4. 线程池的参数配置

<aside>
💡

可修改与不可修改

</aside>

1. 线程池的参数不仅可以通过构造器传参的方式进行设置，还可以使用ThreadPoolExecutor的修改器方法进行修改。

```java
ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(1,
                1,
                1,
                TimeUnit.MINUTES,
	              new ArrayBlockingQueue<>(100));
poolExecutor.setThreadFactory((runnable)->{
    Thread t = new Thread(runnable);
    t.setPriority(5);
    t.setName("tmp-thread");
    return t;
});
poolExecutor.setMaximumPoolSize(100);
```

1. Exectuors提供默认线程池，返回类型都是`ExecutorService`

![image.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/f8287d81-f09a-4ec2-a78a-415ea251091c/83261709-da96-4687-8aec-f3f658d72160/image.png)

- `newSingleThreadExecutor`  方法返回的是通过FinalizableDelegatedExecutorService封装的ExecutorService，使用了代理模式，阻止外部方法对配置做修改。

```java
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

```

- 而其他的默认线程池则可以进行配置信息修改

```java
ExecutorService executorService = Executors.newFixedThreadPool(10);
if (executorService instanceof ThreadPoolExecutor) {
    ThreadPoolExecutor executor = (ThreadPoolExecutor) executorService;
    executor.setMaximumPoolSize(100);
    executor.setCorePoolSize(10);
    System.out.println(String.format("线程池池的核心线程数为%d，最大线程数为%d", executor.getCorePoolSize(), executor.getMaximumPoolSize()));
}
//执行后输出信息为
//  > Task :ThreadPoolExecutorTest.main()
//  线程池池的核心线程数为10，最大线程数为100
```

- 也可以通过调用unconfigurableExecutorService方法，装饰自己创建的线程池，防止参数被修改。

```java
public static ExecutorService unconfigurableExecutorService(ExecutorService executor) {
    if (executor == null)
        throw new NullPointerException();
    return new DelegatedExecutorService(executor);
}
```

# 5. 线程池的钩子函数

```java
//线程执行之前
//Method invoked prior to executing the given Runnable in the given thread. This method is invoked by thread t that will execute task r, and may be used to re-initialize ThreadLocals, or to perform logging.
//This implementation does nothing, but may be customized in subclasses. Note: To properly nest multiple overridings, subclasses should generally invoke super.beforeExecute at the end of this method.
protected void beforeExecute(Thread t, Runnable r) { }

//线程之后之后
//Method invoked upon completion of execution of the given Runnable. This method is invoked by the thread that executed the task. If non-null, the Throwable is the uncaught RuntimeException or Error that caused execution to terminate abruptly.
//This implementation does nothing, but may be customized in subclasses. Note: To properly nest multiple overridings, subclasses should generally invoke super.afterExecute at the beginning of this method.
//Note: When actions are enclosed in tasks (such as FutureTask) either explicitly or via methods such as submit, these task objects catch and maintain computational exceptions, and so they do not cause abrupt termination, and the internal exceptions are not passed to this method. If you would like to trap both kinds of failures in this method, you can further probe for such cases, as in this sample subclass that prints either the direct cause or the underlying exception if a task has been aborted:
protected void afterExecute(Runnable r, Throwable t) { }

//线程池关闭后的钩子，可以在线程池关闭之后处理其他资源或者打日志
protected void terminated() { }
```

博客文章

博客标题 - 这里写文章的主标题

人工智能的最新进展与应用

设计模式学习记录

ThreadPoolExecutor的相关原理