---
title: "Get 线程池队列大小配置"
date: 2026-02-08
lastmod: 2026-02-08
description: "thread_pool.get.queue_size 配置项用于控制文档获取线程池的队列大小。"
tags: ["线程池", "文档获取", "队列管理", "ThreadPool"]
summary: "配置项作用 #  thread_pool.get.queue_size 配置项用于控制文档获取线程池的队列大小。
当所有获取线程都在忙碌时，新的获取请求会被放入队列等待。
配置项属性 #   配置路径: thread_pool.get.queue_size 数据类型: Integer（整数） 默认值: 1000 是否可选: 是 作用域: NodeScope（节点级别） 动态更新: 是（可以动态更新，无需重启）  配置项详解 #  工作机制 #  队列工作机制 线程池结构: ┌─────────────────────────────────────┐ │ Get 线程池 │ ├─────────────────────────────────────┤ │ 执行线程: size (默认 = CPU核心数) │ │ ┌───┬───┬───┬───┐ │ │ │ 1 │ 2 │ 3 │ 4 │ ← 并发执行 │ │ └───┴───┴───┴───┘ │ │ │ │ 等待队列: queue_size (默认 1000) │ │ ┌───┬───┬───┬───┬─ │ │ │ 1 │ 2 │ 3 │ 4 │."
---


## 配置项作用

`thread_pool.get.queue_size` 配置项用于控制**文档获取线程池的队列大小**。

当所有获取线程都在忙碌时，新的获取请求会被放入队列等待。

## 配置项属性

- **配置路径**: `thread_pool.get.queue_size`
- **数据类型**: `Integer`（整数）
- **默认值**: `1000`
- **是否可选**: 是
- **作用域**: NodeScope（节点级别）
- **动态更新**: 是（可以动态更新，无需重启）

## 配置项详解

## 工作机制

```
队列工作机制

线程池结构:
┌─────────────────────────────────────┐
│  Get 线程池                          │
├─────────────────────────────────────┤
│  执行线程: size (默认 = CPU核心数)   │
│  ┌───┬───┬───┬───┐                  │
│  │ 1 │ 2 │ 3 │ 4 │ ← 并发执行       │
│  └───┴───┴───┴───┘                  │
│                                     │
│  等待队列: queue_size (默认 1000)    │
│  ┌───┬───┬───┬───┬─                 │
│  │ 1 │ 2 │ 3 │ 4 │...              │
│  └───┴───┴───┴───┴─                 │
│                                     │
│  满时: 拒绝新请求 ❌                 │
└─────────────────────────────────────┘


任务处理流程:
Get 请求
    │
    ├── 有空闲线程?
    │   ├── 是 → 直接执行 ✅
    │   └── 否 → 检查队列
    │       ├── 队列未满 → 加入队列 ⏳
    │       └── 队列已满 → 拒绝 ❌
    │
    └── 执行完成
        └── 处理队列中下一个
```

## queue_size 设置影响

```
队列大小影响分析

queue_size = 500 (较小):
├── 内存占用: 低 ✅
├── 响应延迟: 低 ✅
├── 吞吐量: 较低 ⚠️
├── 拒绝率: 较高 ⚠️
└-- 适用: 低延迟优先


queue_size = 1000 (默认):
├── 内存占用: 适中 ✅
├── 响应延迟: 适中 ✅
├── 吞吐量: 良好 ✅
├── 拒绝率: 低 ✅
└-- 适用: 大多数场景 ✅


queue_size = 2000 (较大):
├── 内存占用: 较高 ⚠️
├-- 响应延迟: 较高 ⚠️
├── 吞吐量: 高 ✅
├── 拒绝率: 很低 ✅
└-- 适用: 高吞吐优先


queue_size > 5000:
├── 内存占用: 高 ⚠️
├-- 响应延迟: 高 ⚠️
├── OOM 风险: 高 ⚠️
└-- 谨慎使用 ⚠️
```

## 内存占用估算

```
队列内存占用

单个 Get 请求内存:
├── 请求对象: ~1KB
├── 上下文数据: ~2KB
├── 缓冲区: ~4KB
└── 单个请求: ~7KB


不同队列大小的内存占用:

queue_size = 500:
├── 队列内存: 500 × 7KB = 3.5MB
└-- 总计: ~3.5MB


queue_size = 1000 (默认):
├── 队列内存: 1000 × 7KB = 7MB
└-- 总计: ~7MB


queue_size = 2000:
├── 队列内存: 2000 × 7KB = 14MB
└-- 总计: ~14MB


queue_size = 5000:
├── 队列内存: 5000 × 7KB = 35MB
└-- 总计: ~35MB
```

## 配置建议

## 默认配置（推荐）

```yaml
thread_pool:
  get:
    queue_size: 1000  # 默认值
```

**建议**: 大多数场景使用默认值。

## 高吞吐场景

```yaml
thread_pool:
  get:
    queue_size: 2000  # 增加队列
```

**建议**: 高并发查询场景使用。

## 低延迟场景

```yaml
thread_pool:
  get:
    queue_size: 500  # 减少队列
    size: 8  # 增加线程
```

**建议**: 优先保证响应速度时使用。

## 动态更新

```json
PUT /_cluster/settings
{
  "transient": {
    "thread_pool.get.queue_size": 2000
  }
}
```

## 代码示例

## 基础配置

```yaml
thread_pool:
  get:
    queue_size: 1000
```

## 完整配置

```yaml
thread_pool:
  get:
    size: 4
    queue_size: 1000
```

## 查看线程池状态

```bash
GET /_cat/thread_pool/get?v
```

## 查看拒绝的请求

```bash
GET /_cat/thread_pool/get?v&h=active,queue,rejected
```

## 相关配置

| 配置项 | 作用 | 默认值 |
|--------|------|--------|
| `get.queue_size` | 队列大小 | 1000 |
| `get.size` | 线程池大小 | CPU核心数 |

## 注意事项

1. **默认值**: 默认值为 `1000`，适用于大多数场景。

2. **动态更新**: 支持动态更新，无需重启。

3. **内存占用**: 队列占用内存，需考虑资源限制。

4. **与 size 配合**: 应与 `size` 配合调整。

5. **响应延迟**: 队列越长，等待时间可能越长。

6. **拒绝保护**: 队列满时拒绝请求，保护系统。

7. **监控队列**: 定期检查队列使用情况。

8. **合理设置**: 根据实际负载模式设置。

9. **突发流量**: 适当大小可应对突发流量。

10. **OOM 风险**: 过大的队列可能导致内存问题。

## 使用场景

```
场景选择指南

标准查询场景:
├── queue_size: 1000
├── 特点: 查询量平稳
├-- 内存: 充足
└-- 推荐: 默认配置 ✅


突发流量场景:
├── queue_size: 2000-3000
├── 特点: 偶尔高峰
├-- 内存: 需要足够
└-- 推荐: 增加队列


高并发场景:
├── queue_size: 2000
├── size: 增加
├── 特点: 持续高负载
└-- 推荐: 全面优化


低延迟优先:
├── queue_size: 500
├── size: 增加
├── 特点: 响应速度优先
└-- 推荐: 减少队列
```

## 故障排查

```
队列问题排查

问题: Get 请求被拒绝

错误信息:
rejected execution of org.easysearch.action.get.TransportGetAction


排查:
├── 查看线程池状态
│   └── GET /_cat/thread_pool/get?v
│
├── 检查队列是否满
├── 检查活跃线程数
├── 分析请求频率
└-- 评估峰值负载


解决方案:

方案 1: 增加 queue_size ✅ (首选)
├── 提高 thread_pool.get.queue_size
├── 动态更新
└-- 无需重启


方案 2: 增加 size ✅ (配合)
├── 提高 thread_pool.get.size
├── 提高处理能力
└-- 配合队列调整


方案 3: 批量处理 ✅ (长期)
├── 使用 _mget API
├── 减少请求次数
├── 提高效率
└-- 降低峰值


方案 4: 客户端优化 ✅ (保护)
├── 客户端限流
├── 连接池优化
├── 重试机制
└-- 保护系统


问题: 队列积压严重

现象:
├── queue 列持续增长
├── 响应时间变长
└-- 内存占用增加


解决:
├── 增加 size (提高处理能力)
├── 优化查询 (减少处理时间)
├── 批量处理 (减少请求)
├-- 客户端缓存
└-- 检查存储性能
```

## 最佳实践

```
队列管理最佳实践

1. 容量规划
   ├── 估算峰值 QPS
   ├── 计算平均处理时间
   ├── 估算所需队列大小
   └-- 预留缓冲空间


2. 监控告警
   ├── 监控队列长度
   ├── 监控拒绝率
   ├── 设置告警阈值
   │   ├── queue > 80% → 警告
   │   ├── rejected > 0 → 告警
   │   └-- 响应时间 > 阈值 → 告警
   └-- 及时响应


3. 动态调整
   ├── 从默认值开始
   ├── 根据监控调整
   ├── 动态更新配置
   └-- 观察效果


4. 资源平衡
   ├── 考虑内存限制
   ├── 配合 size 调整
   ├── 避免过度配置
   └-- 保持系统平衡


5. 性能测试
   ├── 压力测试队列
   ├── 测试峰值负载
   ├── 验证拒绝率
   └-- 确保稳定性
```