本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# Amazon SQS FIFO 队列
<a name="sqs-fifo-queues"></a>

FIFO（先进先出）队列除了具有[标准队列](standard-queues.md)的所有功能之外，还能在操作和事件的顺序很重要或不能容忍重复项的情况下增强应用程序之间的消息收发。

FIFO 队列最重要的特征是 [*FIFO（先进先出）传递*](FIFO-queues-understanding-logic.md)和*[仅处理一次](FIFO-queues-exactly-once-processing.md)*：
+ 发送和接收消息的顺序严格保持一致；一条消息只会被传递一次，并且在使用者处理并删除该消息之前，其他使用者无法进行处理。
+ 不会将重复项引入到队列中。

此外，FIFO 队列还支持*消息组*，此类组允许一个队列中存在多个有序的消息组。一个 FIFO 队列中的消息组数量没有配额。

您可以使用 FIFO 队列的情况示例如下：

1. 订单至关重要的电子商务订单管理系统

1. 与需要按顺序处理事件的第三方系统集成

1. 按输入顺序处理用户输入的内容

1. 通信和联网 - 按相同的顺序发送和接收数据与信息

1. 计算机系统 - 确保用户输入的命令按正确的顺序运行

1. 教育学院 - 防止学员在注册账户之前参加课程

1. 在线售票系统 - 票按先到先得的原则分发

**注意**  
FIFO 队列还提供“仅处理一次”功能，但每秒事务数 (TPS) 有限。您可以将 Amazon SQS **高吞吐量**模式与 FIFO 队列配合使用，以提高事务限额。有关使用高吞吐量模式的详细信息，请参阅 [Amazon SQS 中 FIFO 队列的高吞吐量](high-throughput-fifo.md)。有关吞吐量配额的信息，请参阅[Amazon SQS 消息配额](quotas-messages.md)。

Amazon SQS FIFO 队列在所有提供 Amazon SQS 的区域推出。

有关使用具有复杂排序功能的 FIFO 队列的更多信息，请参阅[使用 Amazon SQS FIFO 队列解决复杂的排序难题](https://www.amazonaws.cn/blogs/compute/solving-complex-ordering-challenges-with-amazon-sqs-fifo-queues/)。

有关如何使用 Amazon SQS 控制台创建和配置队列的信息，请参阅[使用 Amazon SQS 控制台创建标准队列](creating-sqs-standard-queues.md#step-create-standard-queue)。有关 Java 的示例，请参阅 [Amazon SQS Java SDK 示例](sqs-java-tutorials.md)。

有关使用 FIFO 队列的最佳实践，请参阅 [Amazon SQS 最佳实践](sqs-best-practices.md)。

# Amazon SQS FIFO 队列关键术语
<a name="FIFO-key-terms"></a>

以下关键术语有助于您更好地了解 FIFO 队列的功能。有关更多信息，请参阅 *[Amazon Simple Queue Service API 参考](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/)*。

**客户端**  
Amazon SQS 缓冲异步客户端目前不支持 FIFO 队列。

**消息重复数据删除 ID**  
Amazon SQS FIFO 队列中使用的令牌，用于唯一地标识消息并防止重复。如果在 5 分钟的重复数据删除间隔内发送了多条具有相同重复数据删除 ID 的消息，则这些消息将被视为重复消息，并且系统只传递其中一条。如果您未指定重复数据删除 ID 并且启用了基于内容的重复数据删除，Amazon SQS 会通过对消息正文进行哈希处理来生成重复数据删除 ID。这一机制可以在指定时间范围内消除重复消息，从而确保仅传递一次。  
即使消息已被接收并删除，Amazon SQS 仍会继续跟踪重复数据删除 ID。

**消息组 ID**  
在 FIFO（先进先出）队列中，`MessageGroupId` 是一个将消息组织成不同组的属性。同一消息组内的消息始终按照严格的顺序逐条处理，从而确保同一组内绝不会有两条消息同时被处理。在标准队列中，使用 `MessageGroupId` 启用[公平队列](sqs-fair-queues.md)。如果需要严格排序，请使用 FIFO 队列。

**接收请求尝试 ID**  
接收请求尝试 ID 是 Amazon SQS 中用于删除 [https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html) 重复调用的唯一令牌。

**序列号**  
Amazon SQS 为每条消息分配的大型非连续数字。

**服务**  
如果您的应用程序使用多个 Amazon 服务，或者混合使用外部服务，那么了解哪些服务功能不支持 FIFO 队列非常重要。 Amazon   
尽管允许您将 FIFO 队列设置为目标，但向 Amazon SQS 发送通知的某些 Amazon 或外部服务可能与 FIFO 队列不兼容。  
 Amazon 服务的以下功能目前与 FIFO 队列不兼容：  
+ [Amazon S3 事件通知](https://docs.amazonaws.cn/AmazonS3/latest/userguide/NotificationHowTo.html)
+ [Auto Scaling 生命周期挂钩](https://docs.amazonaws.cn/autoscaling/ec2/userguide/lifecycle-hooks.html)
+ [Amazon IoT 规则操作](https://docs.amazonaws.cn/iot/latest/developerguide/iot-rule-actions.html)
+ [Amazon Lambda 死信队列](https://docs.amazonaws.cn/lambda/latest/dg/invocation-async.html#invocation-dlq)
有关其他服务与 FIFO 队列的兼容性的信息，请参阅服务文档。

# Amazon SQS 中的 FIFO 队列传递逻辑
<a name="FIFO-queues-understanding-logic"></a>

以下概念阐明了 Amazon SQS FIFO 队列如何处理消息的发送和接收，尤其是在处理消息排序和消息组时。 IDs

## 发送消息
<a name="FIFO-sending-messages"></a>

Amazon SQS FIFO 队列使用唯一的重复数据删除 IDs 和消息组来保留消息顺序。 IDs本主题重点介绍了消息组 IDs 对保持组内严格排序的重要性，并重点介绍了确保在多个生产者之间可靠且有序地交付消息的最佳实践。

1. **顺序保存**
   + 当多条消息连续发送到具有唯一消息重复数据删除功能的 FIFO 队列时 IDs，Amazon SQS 会存储这些消息并确认其传输。随后，这些消息将按其确切的传输顺序进行接收和处理。

1. **消息组 ID**
   + 在 FIFO 队列中，消息基于其消息组 ID 进行排序。如果多个创建者或线程发送具有相同消息组 ID 的消息，Amazon SQS 会确保按照消息的到达顺序进行存储和处理。
   + 最佳实践：为确保多个创建者之间的严格消息顺序，应为来自每个创建者的所有消息分配唯一的消息组 ID。

1. **按组排序**
   + **FIFO 队列逻辑应用于每个消息组 ID：**
     + 每个消息组 ID 表示一个不同的、有序的消息组。
     + 在每一个消息组 ID 内，所有消息的发送和接收均严格遵循一定的顺序。
     + 具有不同消息组的消息 IDs 可能会到达或处理顺序混乱。
   + **要求**：您必须将消息组 ID 与每条消息关联。如果消息发送时未指定消息组 ID，则操作将失败。
   + **单个组场景**：如果需要严格遵循一定的顺序处理所有消息，请为每条消息使用相同的消息组 ID。

## 接收消息
<a name="FIFO-receiving-messages"></a>

Amazon SQS FIFO 队列处理消息检索，包括批处理、FIFO 订单保证和请求特定消息组的限制。 IDs本主题介绍 Amazon SQS 如何在保持严格的排序和可见性规则的 IDs 同时检索消息组内和跨消息组的消息。

1. **批量检索**
   + 从包含多个消息组的 FIFO 队列接收消息时 IDs，Amazon SQS：
     + 尝试在单次调用中返回尽可能多的具有相同消息组 ID 的消息。
     + 允许其他使用者 IDs 同时处理来自不同消息组的消息。
   + **重要澄清**
     + 您可以一次性收到来自同一消息组 ID 的多条消息（使用 `MaxNumberOfMessages` 参数，一次调用最多可接收 10 条消息）。
     + 但是，在后续请求中，您无法接收来自同一消息组 ID 的其他消息，除非：
       + 当前接收到的消息被删除，或
       + 它们再次变为可见（例如，在可见性超时结束之后）。

1. **FIFO 顺序保证**
   + 批量检索的消息在组中保留其 FIFO 顺序。
   + 如果同一个消息组 ID 的可用消息少于 10 条，则 Amazon SQS 可能会在同一批次 IDs 中包含来自其他消息组的消息，但每个组都保留 FIFO 顺序。

1. **使用者限制**
   + 您无法显式请求接收具有特定消息组 ID 的消息。

## 多次重试
<a name="FIFO-retrying-multiple-times"></a>

创建者和使用者可以安全地重试 Amazon SQS FIFO 队列中失败的操作，而不会打乱消息顺序或引入重复消息。本主题重点介绍重复数据删除 IDs 和可见性超时如何确保重试期间的消息完整性。

1. **制作人重试**
   + 如果 [https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html) 操作失败，创建者可以使用相同的消息重复数据删除 ID 多次重试发送消息。
   + 只要创建者在重复数据删除间隔到期前收到至少一个确认，重试操作将：
     + 不会引入重复消息。
     + 不会打乱消息顺序。

1. **消费者重试**
   + 如果 [https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html) 操作失败，使用者可以根据需要使用相同的接收请求尝试 ID 重试多次。
   + 只要使用者在可见性超时结束之前收到至少一次确认，则重试：
     + 不会打乱消息顺序。

## 关于 FIFO 行为的其他注意事项
<a name="FIFO-behavior"></a>

了解如何处理可见性超时、启用多个消息组的并行处理以及确保在单组 IDs场景中进行严格的顺序处理。

1. **处理可见性超时**
   + 当消息被检索但未删除时，将保持不可见状态，指导可见性超时结束。
   + 在第一条消息被删除或再次可见之前，系统不会返回来自同一消息组 ID 的其他消息。

1. **并发和并行处理**
   + FIFO 队列允许并行处理不同消息组 IDs中的消息。
   + 为了最大限度地提高并发性，请设计具有多个消息组的系统， IDs 以实现独立的工作流程。

1. **单个组场景**
   + 要严格按顺序处理 FIFO 队列中的所有消息，请为队列中的所有消息使用单个消息组 ID。

## 示例（帮助更好地理解）
<a name="FIFO-examples"></a>

以下实际场景演示了 Amazon SQS 中 FIFO 队列行为。

1. **场景 1：单个组 ID**
   + 创建者发送了 5 条具有相同消息组 ID（Group A）的消息。
   + 使用者按照 FIFO 顺序接收这些消息。在使用者删除这些消息或可见性超时结束之前，不会接收来自 Group A 的其他消息。

1. **场景 2：多个群组 IDs**
   + 创建者向 Group A 发送了 5 条消息，向 Group B 发送了 5 条消息
   + Consumer 1 处理来自 Group A 的消息，而 Consumer 2 处理来自 Group B 的消息。这实现了并行处理，并在每个组内保持严格的顺序。

1. **场景 3：批量检索**
   + 创建者向 Group A 发送了 7 条消息，向 Group B 发送了 3 条消息
   + 单个使用者最多可检索 10 条消息。如果队列允许，它可能会返回：
     + 来自 Group A 的 7 条消息和来自 Group B 的 3 条消息（如果单组可用的消息不足，则返回的数量更少）。

# Amazon SQS 中的仅处理一次
<a name="FIFO-queues-exactly-once-processing"></a>

不同于标准队列，FIFO 队列不会引入重复消息。FIFO 队列可帮助您避免向一个队列发送重复消息。如果您在 5 分钟的重复数据删除时间间隔内重试 `SendMessage` 操作，则 Amazon SQS 不会将任何重复消息引入队列。

要配置重复数据删除，必须执行以下操作之一：
+ 启用基于内容的重复数据删除。这将指示 Amazon SQS 使用 SHA-256 哈希通过消息的正文（而不是消息的属性）生成消息重复数据删除 ID。有关更多信息，请参阅 *Amazon Simple Queue Service API 参考*中 `[CreateQueue](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)`、`[GetQueueAttributes](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html)` 和 `[SetQueueAttributes](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)` 操作的相关文档。
+ 为消息显式提供消息重复数据删除 ID（或查看序列号）。有关更多信息，请参阅 *Amazon Simple Queue Service API 参考*中 `[SendMessage](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)`、`[SendMessageBatch](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)` 和 `[ReceiveMessage](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)` 操作的相关文档。

# 在 Amazon SQS 中，从标准队列移至 FIFO 队列
<a name="FIFO-queues-moving"></a>

如果您的现有应用程序使用标准队列，并且您想要利用 FIFO 队列的排序或“仅处理一次”功能，则需要正确地配置队列和应用程序。

**重要注意事项**
+ **创建 FIFO 队列：**您无法将现有标准队列转换为 FIFO 队列。您必须为应用程序创建新的 FIFO 队列，或者删除现有标准队列并重新将其创建为 FIFO 队列。
+ **延迟参数：**FIFO 队列不支持每消息延迟，仅支持每队列延迟。如果您的应用程序在每条消息上设置 `DelaySeconds` 参数，您必须将应用程序修改为在整个队列上设置 `DelaySeconds`。
+ **消息组 ID：**为每条发送的消息提供一个[消息组 ID](high-throughput-fifo.md#partitions-and-data-distribution)。该 ID 支持并行处理消息，同时保持各组内消息的顺序。为了更好地扩展 FIFO 队列，请为消息组 ID 使用更精细的业务维度。 IDs 您向其分发消息的消息组越多，可供使用的消息数量就越多。
+ **高吞吐量模式：**使用推荐的 FIFO 队列[高吞吐量模式](high-throughput-fifo.md#partitions-and-data-distribution)来提高吞吐量。有关消息配额的更多信息，请参阅[Amazon SQS 消息配额](quotas-messages.md)。

**移至 FIFO 队列的核对清单**

在将消息发送到 FIFO 队列之前，请确认以下内容：

1. **配置延迟设置**
   + 修改应用程序以取消每消息延迟。
   + 在整个队列上设置 `DelaySeconds` 参数。

1. **设置消息组 IDs**
   + 通过基于业务维度指定消息组 ID，将消息整理到消息组中。
   + 使用更精细的业务维度来提高可扩展性。

1. **处理消息重复数据删除**
   + 如果您的应用程序无法发送具有相同消息正文的消息，请针对每条消息提供唯一的消息重复数据删除 ID。
   + 如果您的应用程序发送具有独特的消息正文的消息，请启用基于内容的重复数据删除。

1. **配置使用者**
   + 通常，使用者不需要更改代码。
   + 如果处理消息需要较长时间并且您设置了较高的可见性超时时间，请考虑向每个 `ReceiveMessage` 操作添加接收请求尝试 ID。这样做有助于在网络发生故障时重试接收尝试，并防止由于接收尝试失败而导致队列暂停。

通过执行这些步骤，您可以确保您的应用程序在使用 FIFO 队列时能够正常运行，并充分利用其排序和“仅处理一次”功能。有关更多详细信息，请参阅[《Amazon Simple Queue Service API Reference》](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/)**。

# Amazon SQS FIFO 队列和 Lambda 并发行为
<a name="fifo-queue-lambda-behavior"></a>

通过将 FIFO（先进先出）队列与 Lambda 结合使用，您可以确保每个消息组内消息的有序处理。Lambda 函数不会同时为同一个消息组运行多个实例，从而保证消息处理的顺序。但是，它可以纵向扩展以并行处理多个消息组，从而确保高效处理队列的工作负载。以下几点描述了 Lambda 函数在处理来自消息组的 Amazon SQS FIFO 队列的消息时的行为： IDs
+ **每个消息组对应单个实例：**在任何时候，只有一个 Lambda 实例会处理来自特定消息组 ID 的消息。这样可以确保同一组内的消息按照顺序处理，从而保持 FIFO 顺序的完整性。
+ **并行处理不同的组：**Lambda 可以使用多个实例同时处理来自不同消息组 IDs 的消息。这意味着，当 Lambda 函数的一个实例处理来自一个消息组 ID 的消息时，其他实例可以同时处理来自其他消息组的消息 IDs，利用 Lambda 的并发功能并行处理多个组。

## FIFO 队列消息分组
<a name="fifo-queue-message-grouping"></a>

FIFO 队列可以确保严格按照消息的发送顺序对其进行处理。它们使用**消息组 ID** 对需要按顺序处理的消息进行分组。

同一消息组中的消息按顺序处理，并且系统每次仅处理每个消息组中的一条消息，以便保持该顺序。

## Lambda 与 FIFO 队列的并发处理
<a name="lambda-concurrency-fifo-queues"></a>

创建队列后，您可以向该队列发送消息。

当您设置 Lambda 函数来处理来自 Amazon SQS FIFO 队列的消息时，Lambda 会遵守 FIFO 队列提供的顺序保证。以下几点描述了在使用消息组时处理来自 Amazon SQS FIFO 队列的消息时，Lambda 函数在并发性和扩展方面的行为。 IDs
+ **消息组内的并发性：**一次只有一个 Lambda 实例处理某个特定消息组 ID 的消息。这样可以确保同一组内的消息按照顺序处理。
+ **扩展性和多个消息组：**虽然 Lambda 可以纵向扩展以并发处理消息，但这种扩展是针对不同的消息组进行的。如果您有多个消息组，Lambda 可以并行处理多个消息组，每个消息组由单独的 Lambda 实例处理。

有关更多信息，请参阅《Amazon Lambda Operator Guide》**中的 [Scaling and concurrency in Lambda](https://docs.amazonaws.cn/lambda/latest/operatorguide/scaling-concurrency.html)。

## 使用案例示例
<a name="lambda-concurrency-fifo-queues-example"></a>

假设您的 FIFO 队列收到具有相同消息组 ID 的消息，并且您的 Lambda 函数具有较高的并发限制（最多 1000 条）。

如果系统正在处理来自消息组 ID“A”的一条消息，而来自消息组 ID“A”的另一条消息到达，则在第一条消息完全处理完毕之前，第二条消息不会触发新的 Lambda 实例。

但是，如果来自组 IDs “A” 和 “B” 的消息到达，则这两条消息可以由单独的 Lambda 实例同时处理。

# Amazon SQS 中 FIFO 队列的高吞吐量
<a name="high-throughput-fifo"></a>

Amazon SQS 中的高吞吐量 FIFO 队列可以有效地管理高消息吞吐量，同时保持严格的消息顺序，从而确保处理大量消息的应用程序的可靠性和可扩展性。该解决方案非常适合要求高吞吐量和有序消息传递的场景。

在严格的消息排序并不重要、传入消息量相对较低或偶尔发生的情况下，不需要使用 Amazon SQS 高吞吐量 FIFO 队列。例如，如果您有一个处理到达频率低或不需要按顺序处理的消息的小型应用程序，那么使用高吞吐量 FIFO 队列所产生的复杂性和成本不会带来足够的好处。此外，如果您的应用程序不需要高吞吐量 FIFO 队列提供的增强吞吐能力，那么选择标准 Amazon SQS 队列可能更具成本效益，并且更易于管理。

为了提高高吞吐量 FIFO 队列中的请求容量，建议增加消息组的数量。有关高吞吐量消息配额的更多信息，请参阅《Amazon Web Services 一般参考》**中的 [Amazon SQS 服务限额](https://docs.amazonaws.cn/general/latest/gr/sqs-service.html#limits_sqs.html)。

有关每个队列的配额和数据分配策略的信息，请参阅[Amazon SQS 消息配额](quotas-messages.md)和[SQS FIFO 队列高吞吐量的分区和数据分布](#partitions-and-data-distribution)。

## Amazon SQS FIFO 队列的高吞吐量使用案例
<a name="high-throughput-fifo-use-cases"></a>

以下应用场景重点介绍了高吞吐量 FIFO 队列的不同应用，展示了它们在各行业和场景中的有效性：

1. **实时数据处理：**处理实时数据流（例如事件处理或遥测数据摄取）的应用程序可以利用高吞吐量 FIFO 队列来处理不断涌入的消息，并在保证消息顺序的同时，进行准确分析。

1. **电子商务订单处理：**在电子商务平台中，保持客户交易顺序至关重要，高吞吐量 FIFO 队列可以确保订单按顺序处理并且不会出现延迟，即使在购物高峰期也是如此。

1. **金融服务：**金融机构在处理高频交易或交易数据时，依靠高吞吐量 FIFO 队列以最小的延迟处理市场数据和交易，同时遵守严格的消息顺序监管要求。

1. **媒体流式传输：**流媒体平台和媒体分发服务利用高吞吐量 FIFO 队列来管理媒体文件和流媒体内容的分发，确保用户获得流畅的播放体验，同时保持正确的内容分发顺序。

## SQS FIFO 队列高吞吐量的分区和数据分布
<a name="partitions-and-data-distribution"></a>

Amazon SQS 以分区形式存储 FIFO 队列数据。*分区*是为队列分配的存储空间，该队列在一个 Amazon 区域内的多个可用区之间自动复制。您无需管理分区。相反，Amazon SQS 会负责分区管理。

对于 FIFO 队列，在以下情况下，Amazon SQS 会修改队列中的分区数量：
+ 如果当前请求速率接近或超过现有分区所能支持的速率，则会分配其他分区，直到队列达到区域配额。有关配额的信息，请参阅[Amazon SQS 消息配额](quotas-messages.md)。
+ 如果当前分区的利用率较低，则分区的数量可能会减少。

分区管理在后台自动进行，对程序是透明的。您的队列和消息始终可用。

### 按消息组分发数据 IDs
<a name="data-distribution-message-group-id"></a>

为了将消息添加到 FIFO 队列，Amazon SQS 使用每条消息的消息组 ID 的值作为内部哈希函数的输入。散列函数的输出值决定了哪个分区会存储消息。

下图显示了跨越多个分区的队列。队列的消息组 ID 基于项编号。Amazon SQS 使用其哈希函数决定新项的存储位置；在本例中，它基于字符串 `item0` 的哈希值。请注意，这些项的存储顺序与它们添加到队列的顺序相同。每个项的位置由其消息组 ID 的哈希值决定。

![\[队列跨越多个分区。\]](http://docs.amazonaws.cn/AWSSimpleQueueService/latest/SQSDeveloperGuide/images/fifo-documentation-single.png)


**注意**  
Amazon SQS 经过优化，可以在 FIFO 队列的分区中均匀分配项目，无论分区数量如何。 Amazon 建议您使用可 IDs 包含大量不同值的消息组。

### 优化分区利用率
<a name="data-distribution-partition-limitations"></a>

在支持区域，每个分区支持每秒最多 3000 条消息进行批处理，或者支持每秒最多 300 条消息用于发送、接收和删除操作。有关高吞吐量消息配额的更多信息，请参阅《Amazon Web Services 一般参考》**中的 [Amazon SQS 服务限额](https://docs.amazonaws.cn/general/latest/gr/sqs-service.html#limits_sqs.html)。

使用批处理时 APIs，每条消息都将根据中所[按消息组分发数据 IDs](#data-distribution-message-group-id)述的过程进行路由。路由到同一分区的消息在单个事务中进行分组和处理。

为了优化 `SendMessageBatch` API 的分区利用率， Amazon 建议尽可能使用相同的消息组 IDs 对消息进行批处理。

要优化`DeleteMessageBatch`和的分区利用率 `ChangeMessageVisibilityBatch` APIs， Amazon 建议使用`MaxNumberOfMessages`参数设置为 10 的`ReceiveMessage`请求，并对单个请求返回的接收句柄进行批处理。`ReceiveMessage`

在以下示例中，发送了一批包含不同消息组 IDs 的消息。该批次分为三组，每组都计入分区的配额。

![\[一批具有不同消息组的消息存储 IDs 在分区中。\]](http://docs.amazonaws.cn/AWSSimpleQueueService/latest/SQSDeveloperGuide/images/fifo-documentation-batch.png)


**注意**  
Amazon SQS 仅保证将具有相同消息组 ID 的内部哈希函数的消息分组到批处理请求中。根据内部哈希函数的输出和分区数量， IDs 可能会对具有不同消息组的消息进行分组。由于哈希函数或分区数量可以随时更改，因此，在某一时刻分组的消息以后可能无法分组。

# 为 Amazon SQS 中的 FIFO 队列启用高吞吐量
<a name="enable-high-throughput-fifo"></a>

您可以为任何新的或现有的 FIFO 队列启用高吞吐量。创建和编辑 FIFO 队列时，该特征包括三个新选项：
+ **启用高吞吐量 FIFO** - 增加当前 FIFO 队列消息的吞吐量。
+ **重复数据删除范围** - 指定是在队列级别还是在消息组级别进行重复数据删除。
+ **FIFO 吞吐量限制** - 指定 FIFO 队列中消息的吞吐量配额是在队列级别还是在消息组级别设置的。

**为 FIFO 队列启用高吞吐量（控制台）**

1. 开始[创建](creating-sqs-standard-queues.md#step-create-standard-queue)或[编辑](sqs-configure-edit-queue.md) FIFO 队列。

1. 为队列指定选项时，选择**启用高吞吐量 FIFO**。

   为 FIFO 队列启用高吞吐量会设置相关选项，如下所示：
   + 将**重复数据删除范围**设置为**消息组**，这是为 FIFO 队列使用高吞吐量的必需设置。
   + 将 **FIFO 吞吐量限制**设置为**每个消息组 ID**，这是为 FIFO 队列使用高吞吐量的必需设置。

   如果更改为 FIFO 队列使用高吞吐量所需的任何设置，则队列正常吞吐量生效，重复数据删除按规定进行。

1. 继续为队列指定所有选项。完成后，选择**创建队列**或**保存**。

创建或编辑 FIFO 队列后，您可以向该队列[发送消息](creating-sqs-standard-queues.md#sqs-send-messages)以及[接收和删除消息](step-receive-delete-message.md)，所有这些都以更高的 TPS 完成。有关高吞吐量配额，请参阅[Amazon SQS 消息配额](quotas-messages.md)中的消息吞吐量。

# Amazon SQS 中的 FIFO 队列和消息标识符
<a name="sqs-fifo-queue-message-identifiers"></a>

本节介绍 FIFO 队列的标识符。这些标识符可帮助您查找并操作特定队列和消息。

## Amazon SQS 中的 FIFO 队列标识符
<a name="sqs-general-identifiers"></a>

有关以下标识符的更多信息，请参阅 *[Amazon Simple Queue Service API 参考](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/)*。

### 队列名称和 URL
<a name="fifo-queue-name-url"></a>

在创建新的队列时，您必须为 Amazon 账户和区域指定唯一的队列名称。Amazon SQS 会为您创建的每个队列分配一个名为*队列 URL* 的标识符，其中包含队列名称和其他 Amazon SQS 组件。每当您要对队列执行操作时，都需要提供其队列 URL。

FIFO 队列名称必须以 `.fifo` 后缀结尾。后缀计入 80 个字符的队列名称配额。要确定队列是否为 [FIFO](sqs-fifo-queues.md)，您可以检查队列名称是否以该后缀结尾。

以下是名为 `MyQueue` 的 FIFO 队列的队列 URL，该队列由 AWS 账号为 `123456789012` 的用户所拥有。

```
https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue.fifo
```

您可以通过列出队列并解析账号后的字符串，以编程方式检索队列的 URL。有关更多信息，请参阅 `[ListQueues](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)`。

### 消息 ID
<a name="fifo-message-id"></a>

每条消息都会收到一个系统分配的*消息 ID*，该 ID 由 Amazon SQS 在 `[SendMessage](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)` 响应中返回给您。此标识符用于识别消息。消息 ID 的最大长度为 100 个字符。

### 接收句柄
<a name="fifo-receipt-handle"></a>

每当收到来自队列的消息时，您都会收到该消息的*接收句柄*。此句柄与接收消息的操作相关联，与消息本身无关。要删除消息或更改消息可见性，您必须提供接收句柄（而不是消息 ID）。因此，您必须始终先接收消息，然后才能删除它（您不能将消息放入队列中，然后重新调用它）。接收句柄的最大长度为 1024 个字符。

**重要**  
如果多次接收某条消息，则每次接收该消息时，您都会获得不同的接收句柄。在请求删除该消息时，您必须提供最近收到的接收句柄（否则，可能无法删除该消息）。

以下是一个跨三行显示的接收句柄示例。

```
MbZj6wDWli+JvwwJaBV+3dcjk2YW2vA3+STFFljTM8tJJg6HRG6PYSasuWXPJB+Cw
Lj1FjgXUv1uSj1gUPAWV66FU/WeR4mq2OKpEGYWbnLmpRCJVAyeMjeU5ZBdtcQ+QE
auMZc8ZRv37sIW2iJKq3M9MFx1YvV11A2x/KSbkJ0=
```

## Amazon SQS FIFO 队列的其他标识符
<a name="sqs-additional-fifo-queue-identifiers"></a>

有关以下标识符的更多信息，请参阅[Amazon SQS 中的仅处理一次](FIFO-queues-exactly-once-processing.md)和 *[Amazon Simple Queue Service API 参考](https://docs.amazonaws.cn/AWSSimpleQueueService/latest/APIReference/)*。

### 消息重复数据删除 ID
<a name="sqs-fifo-queue-messagededuplicationid"></a>

Amazon SQS FIFO 队列中使用的令牌，用于唯一地标识消息并防止重复。如果在 5 分钟的重复数据删除间隔内发送了多条具有相同重复数据删除 ID 的消息，则这些消息将被视为重复消息，并且系统只传递其中一条。如果您未指定重复数据删除 ID 并且启用了基于内容的重复数据删除，Amazon SQS 会通过对消息正文进行哈希处理来生成重复数据删除 ID。这一机制可以在指定时间范围内消除重复消息，从而确保仅传递一次。

### 消息组 ID
<a name="sqs-fifo-queue-messagegroupid"></a>

`MessageGroupId` 属性仅用于 Amazon SQS FIFO（先进先出）队列，可将消息组织成不同的组。同一消息组内的消息始终按照严格的顺序逐条处理，从而确保同一组内绝不会有两条消息同时被处理。标准队列不使用 `MessageGroupId`，也不提供顺序保证。如果需要严格排序，请使用 FIFO 队列。

### 序列号
<a name="sqs-fifo-queue-sequence-number"></a>

Amazon SQS 为每条消息分配的大型非连续数字。