缓存与并发
了解 Elasticsearch 的缓存机制，以及如何管理并发来处理大量请求并缩短查询响应时间。
缓存与并发 是 CoddyKit 上的免费 Elasticsearch & Full Text Search Systems 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Elasticsearch & Full Text Search Systems 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Elasticsearch & Full Text Search Systems 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
Boost Performance with Caching
Welcome to Caching and Concurrency! In this lesson, we'll explore how Elasticsearch uses caching to speed up searches and how it manages many requests at once.
Caching is like remembering past answers. If you ask the same question repeatedly, it's faster to recall the answer than to figure it out every time.
Why Caching is Crucial
For search engines, performance is key. Without caching, every query, even identical ones, would require Elasticsearch to re-read data from disk and re-process it.
This leads to higher CPU usage, increased I/O operations, and slower response times. Caching helps reduce this overhead significantly.
The Node Query Cache
Elasticsearch uses several caches. One important one is the Node Query Cache. This cache stores the results of frequently used filter queries.
It operates at the node level and is great for speeding up queries that use common filters, like "status": "active", without re-evaluating them.
GET /my_index/_search
{
"query": {
"bool": {
"filter": {
"term": {
"category.keyword": "electronics"
}
}
}
}
}How Node Query Cache Works
The Node Query Cache stores the *bitsets* representing which documents match a filter. When a filter is used again, Elasticsearch can quickly retrieve this bitset instead of scanning all documents.
It's optimized for queries that are small, frequently run, and don't involve complex aggregations or full-text analysis.
The Request Cache
Another vital cache is the Request Cache. This cache stores the *entire JSON response* of a search request for a specific shard.
It's useful for queries that are identical, including their aggregations, and are run often. It offers a significant speed boost by returning the pre-computed response.
GET /my_index/_search?request_cache=true
{
"size": 0,
"aggs": {
"categories": {
"terms": {
"field": "category.keyword"
}
}
}
}Doc Values: Modern Field Data
Historically, Elasticsearch used a 'Field Data Cache' for sorting and aggregations on text fields. This could consume a lot of memory.
Today, Elasticsearch uses Doc Values by default for numeric, boolean, date, IP, and keyword fields. Doc Values are stored on disk in a column-oriented fashion, making them very efficient for aggregations and sorting without heavy memory use.
PUT /products
{
"mappings": {
"properties": {
"price": {
"type": "float"
},
"status": {
"type": "keyword"
}
}
}
}Cache Invalidation
Caches are great, but they must be up-to-date. When you index, update, or delete a document in an index, Elasticsearch automatically invalidates (clears) the relevant cached entries for that shard.
This ensures that new searches always reflect the latest data, preventing stale results from being served.
Concurrency: Handling Many Requests
Beyond caching, Elasticsearch needs to handle many users querying and indexing data simultaneously. This is called concurrency.
Elasticsearch achieves concurrency by using multiple threads and thread pools, allowing it to process several operations at the same time without waiting for each one to finish sequentially.
Elasticsearch Thread Pools
Elasticsearch organizes tasks using different thread pools. Each pool handles a specific type of operation:
- Search pool: For executing search queries.
- Index pool: For indexing and updating documents.
- Bulk pool: For handling bulk indexing requests.
These pools prevent one slow operation from blocking others.
GET /_cat/thread_pool?vQueues and Rejection
When a thread pool is busy, incoming requests are placed into a queue. If the queue becomes full, Elasticsearch will start rejecting new requests for that operation type.
Rejected requests result in an error (e.g., HTTP 429 Too Many Requests). This mechanism is crucial for preventing the cluster from becoming overloaded and unstable.
Cache & Concurrency Check
Test your understanding of caching and concurrency in Elasticsearch.
Recap: Caching & Concurrency
In this lesson, we explored how Elasticsearch optimizes performance through caching and concurrency:
- Caching: The Node Query Cache and Request Cache store query results to avoid re-computation.
- Doc Values: An efficient, disk-based structure for aggregations and sorting.
- Concurrency: Elasticsearch uses thread pools to manage many simultaneous requests for search, indexing, and bulk operations.
- Queues: Requests are queued when busy, with rejection as a safeguard against overload.
Understanding these mechanisms helps you build faster and more resilient search applications!
常见问题解答
「缓存与并发」课时是免费的吗？
是的 — 「缓存与并发」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Elasticsearch & Full Text Search Systems 课程的其余内容，请升级到 CoddyKit PRO。 Elasticsearch & Full Text Search Systems 课程共包含 4 节课。
「缓存与并发」这节课中我会学到什么？
了解 Elasticsearch 的缓存机制，以及如何管理并发来处理大量请求并缩短查询响应时间。 你通过在浏览器中直接运行的动手代码来练习 Elasticsearch & Full Text Search Systems，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Elasticsearch & Full Text Search Systems 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Elasticsearch & Full Text Search Systems 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。
「缓存与并发」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Elasticsearch & Full Text Search Systems 课中编写并运行代码吗？
能。每节 Elasticsearch & Full Text Search Systems 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。