תורים ב-Spanner מעבירים הודעות לפחות פעם אחת, והם מיועדים לעיבוד מקביל בכמה מקלטים. כשכמה הודעות לאותה ישות (כמו חשבון לקוח, הזמנה או מכשיר) נשלחות לתור, עובדים שונים יכולים למשוך ולעבד אותן בו-זמנית. גם אם הודעה אחת נשלחת ראשונה, עיכוב ברשת או ניסיון חוזר יכולים להאט את ה-worker הראשון בזמן ש-worker שני מסיים הודעה מאוחרת יותר.
אם כל הודעה בתור הייתה מעובדת בסדר גלובלי קפדני, עובד איטי אחד היה יכול לעכב את כל התור (תופעה שנקראת חסימה בראש התור). עם זאת, ברוב האפליקציות לא צריך שכל הודעה במסד הנתונים כולו תמתין בתור גלובלי אחד. במקום זאת, אתם צריכים להריץ לפי הסדר רק משימות של אותה ישות, בזמן שמשימות של ישויות שונות פועלות במקביל. אתם יכולים להשתמש בתבניות הבאות כדי לעבד הודעות לפי סדר לכל ישות, בהתאם לעומס העבודה.
שרשור הודעות לתהליכי עבודה רציפים
כשמשימה ברקע של ישות מורכבת משלבים עוקבים תלויים (לדוגמה, step-1 ואחריו step-2 ו-step-3), ובקשות חיצוניות לא מוסיפות משימות מתחרות לתהליך העבודה הזה במקביל, אתם רוצים שכל שלב יתחיל רק אחרי שהשלב הקודם מסתיים.
כדי לאכוף סדר של שלב אחר שלב, צריך להוסיף לתור רק את השלב הראשון בהתחלה. כשה-worker מסיים לעבד את השלב הנוכחי, הוא מאשר את ההודעה הנוכחית (DELETE ... ASSERT_ROWS_MODIFIED 1) ומכניס את ההודעה לשלב הבא באותה טרנזקציית קריאה-כתיבה.
מכיוון שההודעה לשלב הבא לא נוצרת עד שהשלב הנוכחי הושלם ואושר באותה טרנזקציה, שני שלבים של אותו תהליך עבודה אף פעם לא קיימים בתור בו-זמנית, ולא יכולים להיות מעובדים בסדר שונה על ידי וורקרים בו-זמניים.
לדוגמה, כשעובד מסיים step-1 מתהליך העבודה של הכשרת עובדים חדשים ומתזמן step-2:
GoogleSQL
-- Inside the worker transaction after finishing step-1:
-- 1. Acknowledge the current step
DELETE FROM OnboardingQueue
WHERE CustomerId = 456 AND StepName = 'step-1'
ASSERT_ROWS_MODIFIED 1;
-- 2. Enqueue the next step in the sequence
INSERT INTO OnboardingQueue (CustomerId, StepName, DeliverTime, Payload)
VALUES (456, 'step-2', CURRENT_TIMESTAMP(), b'{"stage": "provision_resources"}');
PostgreSQL
-- Inside the worker transaction after finishing step-1:
-- 1. Acknowledge the current step
DELETE FROM onboardingqueue
WHERE customerid = 456 AND stepname = 'step-1'
ASSERT_ROWS_MODIFIED 1;
-- 2. Enqueue the next step in the sequence
INSERT INTO onboardingqueue (customerid, stepname, deliver_time, payload)
VALUES (456, 'step-2', CURRENT_TIMESTAMP, CAST('{"stage": "provision_resources"}' AS bytea));
שימוש בטבלת עבודה מסודרת ובתור התעוררות
עם זאת, כשצריך שכל המשימות של ישות מסוימת יפעלו לפי סדר השמירה, גם כשבקשות חיצוניות, תגובות לפעולות אינטרנט או פעולות של משתמשים מוסיפות משימות חדשות בזמן שהמשימות הקודמות עדיין מעובדות, התבנית הזו תומכת בעומסי עבודה שמתאימים לקיבולת הכתיבה של פיצול יחיד.
כדי לעבד משימות בו-זמניות לפי הסדר לכל ישות, מרחיבים את תבנית הדגל המלוכלך על ידי אחסון משימות מסודרות בטבלה משולבת, ומשתמשים בתור רק להתראות התעוררות קלות.
קודם כול, משלבים טבלת עבודה מסודרת (באמצעות חותמות זמן של ביצוע שינויים) ותור התעוררות בטבלת ישות אם שעוקבת אחרי התביעה הפעילה. כדי למנוע נקודות חמות בין פיצולים, צריך לבחור מפתח ראשי (כמו UUID או רצף סיביות הפוך) שמפיץ ישויות באופן שווה:
GoogleSQL
CREATE SEQUENCE CustomerIdSeq OPTIONS (sequence_kind = 'bit_reversed_positive');
CREATE TABLE Customers (
CustomerId INT64 NOT NULL DEFAULT (GET_NEXT_SEQUENCE_VALUE(SEQUENCE CustomerIdSeq)),
CustomerName STRING(1024),
IsProcessing BOOL NOT NULL DEFAULT (FALSE),
ActiveClaimId STRING(36),
ProcessingExpiresAt TIMESTAMP,
) PRIMARY KEY (CustomerId);
CREATE TABLE CustomerWorkItems (
CustomerId INT64 NOT NULL,
CreatedAt TIMESTAMP NOT NULL DEFAULT (PENDING_COMMIT_TIMESTAMP())
OPTIONS (allow_commit_timestamp = true),
BatchIndex INT64 NOT NULL DEFAULT (0),
WorkType STRING(128) NOT NULL,
WorkPayload JSON NOT NULL,
) PRIMARY KEY (CustomerId, CreatedAt, BatchIndex),
INTERLEAVE IN PARENT Customers ON DELETE CASCADE;
CREATE QUEUE CustomerDirtyQueue (
CustomerId INT64 NOT NULL,
MessageId STRING(36) NOT NULL,
Payload BYTES(MAX) NOT NULL,
) PRIMARY KEY (CustomerId, MessageId),
INTERLEAVE IN PARENT Customers ON DELETE CASCADE;
PostgreSQL
CREATE SEQUENCE customeridseq BIT_REVERSED_POSITIVE;
CREATE TABLE customers (
customerid bigint NOT NULL DEFAULT nextval('customeridseq'),
customername varchar(1024),
isprocessing boolean NOT NULL DEFAULT false,
activeclaimid varchar(36),
processingexpiresat timestamptz,
PRIMARY KEY (customerid)
);
CREATE TABLE customerworkitems (
customerid bigint NOT NULL,
createdat spanner.commit_timestamp NOT NULL DEFAULT spanner.pending_commit_timestamp(),
batchindex bigint NOT NULL DEFAULT 0,
worktype varchar(128) NOT NULL,
workpayload jsonb NOT NULL,
PRIMARY KEY (customerid, createdat, batchindex)
) INTERLEAVE IN PARENT customers ON DELETE CASCADE;
CREATE QUEUE customerdirtyqueue (
customerid bigint NOT NULL,
messageid varchar(36) NOT NULL,
payload bytea NOT NULL,
PRIMARY KEY (customerid, messageid)
) INTERLEAVE IN PARENT customers ON DELETE CASCADE;
כשהסכימה הזו מוגדרת, השולחים וה-workers מתואמים לפי תהליך העבודה הבא:
- הוספת משימות מסודרות והודעת התעוררות: בטרנזקציה של השולח, מוסיפים את המשימות ל-
CustomerWorkItems(באמצעותPENDING_COMMIT_TIMESTAMP()ו-BatchIndexמבוסס-אפס כדי לסדר כמה משימות באותה טרנזקציה) ומוסיפים הודעת התעוררות אחת עם מטען ייעודי ריק (b'') ל-CustomerDirtyQueue. - כדי להגיש תלונה, לעבד את הישות ולבטל את התלונה, מבצעים את שלושת השלבים הבאים:
- שלב 1 (תביעת בעלות על הישות בטרנזקציה 1): כש-worker מקבל הודעת השכמה מ-
RECEIVE_CustomerDirtyQueue, הוא מריץ טרנזקציית קריאה-כתיבה קצרה:- בודקים את
Customersומאשרים את הודעת ההתעוררות הנכנסת (DELETE ... ASSERT_ROWS_MODIFIED 1). אם ל-worker אחר כבר יש תביעה פעילה (IsProcessing = TRUEו-ProcessingExpiresAt > CURRENT_TIMESTAMP()), מבצעים את Transaction 1 ויוצאים. ה-worker הפעיל בודק אם נותרו משימות לפני שהוא משחרר את התביעה שלו. - אחרת, קוראים את קבוצת המשימות הישנה ביותר (לדוגמה,
LIMIT 25) מ-CustomerWorkItemsלפי הסדר שלCreatedAt ASC, BatchIndex ASC, ומוחקים את כל הודעות הגיבוי שנותרו ושתוקפן פג (שה-MessageIdשלהן הוא ה-ActiveClaimIdהקודם). - אם מוחזרות משימות, מגדירים את
IsProcessing = TRUE,ActiveClaimIdו-ProcessingExpiresAt(למשל, 10 שניות בעתיד) ב-Customers, ומכניסים הודעת חלופית (MessageId = ActiveClaimId) ל-CustomerDirtyQueueשמתוזמנת ל-ProcessingExpiresAt. אם לא נותרו משימות, מאפסים אתIsProcessing = FALSE,ActiveClaimId = NULLו-ProcessingExpiresAt = NULL.
- בודקים את
- שלב 2 (עיבוד משימות מחוץ לעסקה): אחרי ש-Transaction 1 מסתיים, ה-worker מריץ את המשימות ברצף בקוד האפליקציה. אם משימה נכשלת, ה-worker מפסיק את האצווה מוקדם ועדיין מריץ את שלב 3, כך שהמשימות שהושלמו נמחקות לפני שהוא מנסה שוב להריץ את המשימה שנכשלה.
- שלב 3 (מחיקת המשימות שהושלמו ושחרור הישות בטרנזקציה 2): ה-worker פותח טרנזקציה שנייה קצרה לקריאה ולכתיבה, מוחק את הודעת הגיבוי (
ActiveClaimId) מ-CustomerDirtyQueueבאמצעותASSERT_ROWS_MODIFIED 1, מוחק את המשימות שהושלמו מ-CustomerWorkItems, מוסיף הודעת התעוררות חדשה אם נותרו עוד משימות ב-CustomerWorkItemsומאפס אתIsProcessing = FALSE,ActiveClaimId = NULLו-ProcessingExpiresAt = NULLב-Customers.
- שלב 1 (תביעת בעלות על הישות בטרנזקציה 1): כש-worker מקבל הודעת השכמה מ-
התבנית הזו שומרת על סדר קפדני לכל ישות ועל קצב העברת נתונים גבוה מהסיבות הבאות:
- סדר חותמות הזמן של ה-commit: אחסון משימות ב-
CustomerWorkItemsעם מפתח לפי(CustomerId, CreatedAt, BatchIndex)מסדר כל משימה לפי חותמת הזמן של ה-commit של הטרנזקציה, גם כשכמה שולחים כותבים בו-זמנית. - לוקליזציה של פיצול יחיד:
שזירה
CustomerWorkItemsו-CustomerDirtyQueueב-Customersשומרת על מצב ההצהרה, המשימות והודעות ההתעוררות של הישות באותו פיצול. אם משאירים אתCustomerDirtyQueue.Payloadריק (b''), זה גם מצמצם את נפח האחסון בתור ואת התקורה של המסירה בזיכרון. - נעילות קצרות של מסד הנתונים: החזקת טרנזקציית קריאה-כתיבה פתוחה במהלך שלב 2 נועלת את השורה
Customersוחוסמת שולחים בו-זמנית. פיצול התביעה (עסקה 1) וההשלמה (עסקה 2) לשתי עסקאות קצרות מבטיח שרק עובד אחד מעבד ישות בכל פעם, בלי להחזיק נעילות של מסד נתונים בזמן שקוד האפליקציה פועל. - התאוששות מקריסה וגידור: אישור מיידי של הודעת ההתעוררות הראשונית בטרנזקציה 1 ותזמון הודעת גיבוי (
ActiveClaimId) ב-ProcessingExpiresAtמחליפים את השכירות הקבועה של 10 שניות להודעתRECEIVEבתביעת ישות שניתנת להגדרה. אם ה-worker קורס במהלך שלב 2, ההודעה החלופית מבשילה ומעירה worker אחר. אם עובד איטי מסיים אחרי שתוקף התביעה שלו פג ועובד אחר כבר השתלט, מחיקתActiveClaimIdעםASSERT_ROWS_MODIFIED 1בטרנזקציה 2 נכשלת עםOUT_OF_RANGE. הפצת השגיאה הזו (או החזרה מפורשת למצב קודם) מבטלת את עסקה 2 לפני שניתן לבצע את פעולות הכתיבה האלה.
ההצהרות הבאות מוסיפות שתי משימות מסודרות והודעת התעוררות בטרנזקציה אחת של השולח:
GoogleSQL
-- 1. Insert ordered tasks for the entity using a 0-based BatchIndex
INSERT INTO CustomerWorkItems (CustomerId, CreatedAt, BatchIndex, WorkType, WorkPayload)
VALUES
(456, PENDING_COMMIT_TIMESTAMP(), 0, 'ORDER_CREATED', JSON '{"order_id": 1001}'),
(456, PENDING_COMMIT_TIMESTAMP(), 1, 'PAYMENT_CAPTURED', JSON '{"order_id": 1001}');
-- 2. Send a single lightweight wake-up message to the interleaved queue
INSERT INTO CustomerDirtyQueue (CustomerId, MessageId, DeliverTime, Payload)
VALUES (456, 'msg-uuid-1', CURRENT_TIMESTAMP(), b'');
PostgreSQL
-- 1. Insert ordered tasks for the entity using a 0-based batchindex
INSERT INTO customerworkitems (customerid, createdat, batchindex, worktype, workpayload)
VALUES
(456, spanner.pending_commit_timestamp(), 0, 'ORDER_CREATED', '{"order_id": 1001}'::jsonb),
(456, spanner.pending_commit_timestamp(), 1, 'PAYMENT_CAPTURED', '{"order_id": 1001}'::jsonb);
-- 2. Send a single lightweight wake-up message to the interleaved queue
INSERT INTO customerdirtyqueue (customerid, messageid, deliver_time, payload)
VALUES (456, 'msg-uuid-1', CURRENT_TIMESTAMP, CAST('' AS bytea));
הצהרות ה-SQL הבאות מראות איך ה-worker מקבל הודעות התעוררות, תובע בעלות על הישות בטרנזקציה 1 ומשחרר את הישות בטרנזקציה 2:
GoogleSQL
-- Stream wake-up messages from the queue:
SELECT CustomerId, MessageId, Payload, DeliverTime, SpannerLeaseToken
FROM RECEIVE_CustomerDirtyQueue(max_duration=>'20m', max_batch_size=>10);
-- Transaction 1 (claim the entity):
-- 1. Check whether another worker holds an active claim on the entity
SELECT
IsProcessing,
ActiveClaimId,
IFNULL(ProcessingExpiresAt > CURRENT_TIMESTAMP(), FALSE) AS HasActiveClaim
FROM Customers
WHERE CustomerId = 456;
-- Always acknowledge the incoming wake-up message in Transaction 1.
-- Let OUT_OF_RANGE propagate to roll back the transaction so duplicate workers exit.
-- If IsProcessing = TRUE and HasActiveClaim = TRUE, commit after this DELETE and exit.
DELETE FROM CustomerDirtyQueue
WHERE CustomerId = 456 AND MessageId = 'msg-uuid-1'
ASSERT_ROWS_MODIFIED 1;
-- 2. Only if no active claim exists, read the next ordered batch of work items
SELECT CreatedAt, BatchIndex, WorkType, WorkPayload
FROM CustomerWorkItems
WHERE CustomerId = 456
ORDER BY CreatedAt ASC, BatchIndex ASC
LIMIT 25;
-- 3. Always clean up any remaining expired fallback message
-- (when ActiveClaimId IS NOT NULL AND ActiveClaimId != 'msg-uuid-1'):
DELETE FROM CustomerDirtyQueue
WHERE CustomerId = 456 AND MessageId = 'expired-claim-uuid';
-- 4. If step 2 returns work items, schedule a 10-second fallback message
-- and mark the entity as busy. (If step 2 returns no rows, clear any
-- expired claim fields on Customers instead.)
INSERT INTO CustomerDirtyQueue (CustomerId, MessageId, DeliverTime, Payload)
VALUES (456, 'claim-uuid-2', TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 10 SECOND), b'');
UPDATE Customers
SET IsProcessing = TRUE,
ActiveClaimId = 'claim-uuid-2',
ProcessingExpiresAt = TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 10 SECOND)
WHERE CustomerId = 456;
-- Transaction 2 (after processing the batch in order outside a transaction):
-- 1. Verify the claim is still active by deleting the fallback message.
-- Let OUT_OF_RANGE propagate to roll back the transaction if another worker took over.
DELETE FROM CustomerDirtyQueue
WHERE CustomerId = 456 AND MessageId = 'claim-uuid-2'
ASSERT_ROWS_MODIFIED 1;
-- 2. Delete the completed work items
DELETE FROM CustomerWorkItems
WHERE CustomerId = 456
AND CreatedAt = TIMESTAMP '2026-05-01T12:00:00.123456Z'
AND BatchIndex IN (0, 1);
-- 3. Check whether any unprocessed work items remain:
SELECT 1 FROM CustomerWorkItems
WHERE CustomerId = 456
LIMIT 1;
-- Run this INSERT only if the preceding SELECT returned a row:
INSERT INTO CustomerDirtyQueue (CustomerId, MessageId, DeliverTime, Payload)
VALUES (456, 'continuation-uuid-3', CURRENT_TIMESTAMP(), b'');
-- 4. Release the entity claim
UPDATE Customers
SET IsProcessing = FALSE, ActiveClaimId = NULL, ProcessingExpiresAt = NULL
WHERE CustomerId = 456 AND ActiveClaimId = 'claim-uuid-2';
PostgreSQL
-- Stream wake-up messages from the queue:
SELECT customerid, messageid, payload, deliver_time, spanner_lease_token
FROM spanner.receive_customerdirtyqueue(
max_batch_size=>10, priority=>NULL, max_duration=>'20m');
-- Transaction 1 (claim the entity):
-- 1. Check whether another worker holds an active claim on the entity
SELECT
isprocessing,
activeclaimid,
COALESCE(processingexpiresat > CURRENT_TIMESTAMP, false) AS hasactiveclaim
FROM customers
WHERE customerid = 456;
-- Always acknowledge the incoming wake-up message in Transaction 1.
-- Let OUT_OF_RANGE propagate to roll back the transaction so duplicate workers exit.
-- If isprocessing = true and hasactiveclaim = true, commit after this DELETE and exit.
DELETE FROM customerdirtyqueue
WHERE customerid = 456 AND messageid = 'msg-uuid-1'
ASSERT_ROWS_MODIFIED 1;
-- 2. Only if no active claim exists, read the next ordered batch of work items
SELECT createdat, batchindex, worktype, workpayload
FROM customerworkitems
WHERE customerid = 456
ORDER BY createdat ASC, batchindex ASC
LIMIT 25;
-- 3. Always clean up any remaining expired fallback message
-- (when activeclaimid IS NOT NULL AND activeclaimid != 'msg-uuid-1'):
DELETE FROM customerdirtyqueue
WHERE customerid = 456 AND messageid = 'expired-claim-uuid';
-- 4. If step 2 returns work items, schedule a 10-second fallback message
-- and mark the entity as busy. (If step 2 returns no rows, clear any
-- expired claim fields on customers instead.)
INSERT INTO customerdirtyqueue (customerid, messageid, deliver_time, payload)
VALUES (456, 'claim-uuid-2', CURRENT_TIMESTAMP + INTERVAL '10 SECOND', CAST('' AS bytea));
UPDATE customers
SET isprocessing = true,
activeclaimid = 'claim-uuid-2',
processingexpiresat = CURRENT_TIMESTAMP + INTERVAL '10 SECOND'
WHERE customerid = 456;
-- Transaction 2 (after processing the batch in order outside a transaction):
-- 1. Verify the claim is still active by deleting the fallback message.
-- Let OUT_OF_RANGE propagate to roll back the transaction if another worker took over.
DELETE FROM customerdirtyqueue
WHERE customerid = 456 AND messageid = 'claim-uuid-2'
ASSERT_ROWS_MODIFIED 1;
-- 2. Delete the completed work items
DELETE FROM customerworkitems
WHERE customerid = 456
AND createdat = '2026-05-01T12:00:00.123456Z'::timestamptz
AND batchindex IN (0, 1);
-- 3. Check whether any unprocessed work items remain:
SELECT 1 FROM customerworkitems
WHERE customerid = 456
LIMIT 1;
-- Run this INSERT only if the preceding SELECT returned a row:
INSERT INTO customerdirtyqueue (customerid, messageid, deliver_time, payload)
VALUES (456, 'continuation-uuid-3', CURRENT_TIMESTAMP, CAST('' AS bytea));
-- 4. Release the entity claim
UPDATE customers
SET isprocessing = false, activeclaimid = NULL, processingexpiresat = NULL
WHERE customerid = 456 AND activeclaimid = 'claim-uuid-2';
מניעת כפילויות של הודעות התעוררות מתפרצות באמצעות קיבוץ זמני
כשישות מקבלת פרצים תכופים של עדכונים תוך כמה שניות, שליחת הודעת התעוררות נפרדת בכל טרנזקציה יוצרת כתיבות מיותרות בתור ושליחות מיותרות של הודעות התעוררות.
כדי לאחד הודעות התעוררות בזמן הכתיבה, משלבים אצווה זמנית עם MessageId דטרמיניסטי:
- מגדירים את
MessageIdלמזהה הקטגוריה של חלון הזמן (לדוגמה, קטגוריה של 5 שניות). - מעגלים את
DeliverTimeכלפי מעלה לחלון הזמן הבא, בתוספת היסט לכל ישות שמחושב באמצעותFARM_FINGERPRINT(אוspanner.farm_fingerprint). - מזינים את הודעת ההתעוררות באמצעות
INSERT OR IGNOREב-GoogleSQL אוINSERT ... SELECT ... FROM ... WHERE NOT EXISTSב-PostgreSQL.
כל עסקה של אותה ישות בחלון הזמן הזה של 5 שניות מחשבת את אותם MessageId ו-DeliverTime. כל הטרנזקציות מוסיפות את המשימות שלהן ל-CustomerWorkItems, אבל רק הטרנזקציה הראשונה בחלון כותבת הודעת התעוררות ל-CustomerDirtyQueue. הוספת היסט לכל ישות מפזרת את זמני המסירה על פני מרווח של 5 שניות, כך שישויות שונות לא מופעלות כולן באותה שנייה בדיוק.
לדוגמה, הטרנזקציה הבאה של השולח מאחדת הודעות התעוררות לקטגוריות של 5 שניות:
GoogleSQL
-- 1. Insert the ordered work item
INSERT INTO CustomerWorkItems (CustomerId, CreatedAt, BatchIndex, WorkType, WorkPayload)
VALUES (456, PENDING_COMMIT_TIMESTAMP(), 0, 'METRIC_RECORDED', JSON '{"v": 42}');
-- 2. Coalesce wake-up messages into a 5-second window with a per-customer offset
INSERT OR IGNORE INTO CustomerDirtyQueue (CustomerId, MessageId, DeliverTime, Payload)
VALUES (
456,
CONCAT('bucket-', CAST(DIV(UNIX_SECONDS(CURRENT_TIMESTAMP()), 5) * 5 AS STRING)),
TIMESTAMP_SECONDS(
DIV(UNIX_SECONDS(CURRENT_TIMESTAMP()), 5) * 5 + 5
+ MOD(ABS(FARM_FINGERPRINT(CAST(456 AS STRING))), 5)
),
b''
);
PostgreSQL
-- 1. Insert the ordered work item
INSERT INTO customerworkitems (customerid, createdat, batchindex, worktype, workpayload)
VALUES (456, spanner.pending_commit_timestamp(), 0, 'METRIC_RECORDED', '{"v": 42}'::jsonb);
-- 2. Coalesce wake-up messages into a 5-second window with a per-customer offset
INSERT INTO customerdirtyqueue (customerid, messageid, deliver_time, payload)
SELECT
456,
'bucket-' || bucket.start_sec::text,
to_timestamp(
bucket.start_sec + 5
+ (abs(spanner.farm_fingerprint(456::text)) % 5)
),
CAST('' AS bytea)
FROM (
SELECT (floor(EXTRACT(EPOCH FROM CURRENT_TIMESTAMP))::bigint / 5) * 5 AS start_sec
) AS bucket
WHERE NOT EXISTS (
SELECT 1 FROM customerdirtyqueue
WHERE customerid = 456
AND messageid = 'bucket-' || bucket.start_sec::text
);
צמצום התחרות על נעילה מהודעות התעוררות בו-זמניות
כשכמה הודעות השכמה לאותה ישות עסוקה מגיעות באותו זמן, כמה וורקרים יכולים להתחיל את טרנזקציה 1 בו-זמנית ולהתחרות על נעילות קריאה-כתיבה באותה שורה ב-Customers.
כדי לצמצם את התחרות על נעילות בישויות חמות, מבצעים קריאה יחידה (client.Single()) ללא נעילה לפני שמתחילים את עסקה 1, כדי לבדוק אם IsProcessing = TRUE ו-ProcessingExpiresAt > CURRENT_TIMESTAMP(). אם הישות עסוקה, ממתינים זמן קצר באופן אקראי (למשל 10 עד 50 אלפיות השנייה) לפני שמריצים את טרנזקציה 1 כדי לבדוק שוב את Customers ולאשר את הודעת ההפעלה הכפולה.
קריאה אחת בודקת את סטטוס התביעה של הישות בלי לרכוש נעילות קריאה-כתיבה, וההשהיה האקראית מפרידה בין עסקאות הקריאה-כתיבה הבאות, כך שהעובדים לא מתחרים על השורה Customers באותה אלפית השנייה. חשוב תמיד לבדוק שוב את IsProcessing בתוך עסקה 1 לפני שמוחקים את הודעת ההתעוררות, כדי שאם ה-worker הפעיל יסיים מיד אחרי הקריאה היחידה, הודעת ההתעוררות לא תימחק בזמן שמשימות חדשות נשארות ללא עיבוד.
לדוגמה, הפונקציה הבאה ב-Go מחילה השהיה אקראית כשישות כבר עסוקה:
func maybeJitterBeforeClaim(ctx context.Context, client *spanner.Client, customerID int64) error {
iter := client.Single().Query(ctx, spanner.Statement{
SQL: `SELECT IsProcessing AND IFNULL(ProcessingExpiresAt > CURRENT_TIMESTAMP(), FALSE) AS IsBusy
FROM Customers WHERE CustomerId = @cid`,
Params: map[string]interface{}{"cid": customerID},
})
defer iter.Stop()
row, err := iter.Next()
if errors.Is(err, iterator.Done) {
return nil
}
if err != nil {
return err
}
var isBusy bool
if err := row.Columns(&isBusy); err != nil {
return err
}
if isBusy {
time.Sleep(time.Duration(10+rand.Intn(40)) * time.Millisecond)
}
return nil
}
טיפול באצוות שפועלות לאורך זמן ובקריאות חיצוניות
כשעיבוד של קבוצת משימות נמשך יותר מחלון הזמן הראשוני של 10 שניות ב-ProcessingExpiresAt, או כשמתבצעות קריאות לממשקי API חיצוניים (כמו Payment Gateway או תגובות לפעולה מאתר אחר (webhook)) שלא מתבטלות כשטרנזקציה במסד הנתונים נכשלת, צריך למנוע פעולות חיצוניות כפולות ותפוגה מוקדמת של הצהרות.
כדי להגן על קריאות חיצוניות ולהאריך את תביעות הישות של אצוות איטיות:
- העברת מפתח אידמפוטנטיות דטרמיניסטי לממשקי API חיצוניים: משלבים את
CustomerId,CreatedAtו-BatchIndex(לדוגמה,456:2026-05-01T12:00:00.123456Z:0) ומעבירים את המפתח הזה לשירותים במורד הזרם במהלך שלב 2. - הארכת התביעה על הישות באמצעות אות פעימה תקופתי: אפשר להגדיר ערך ראשוני
ProcessingExpiresAtוערך חלופיDeliverTimeארוכים יותר (למשל 30 או 60 שניות) בטרנזקציה 1, או להריץ טרנזקציה של אות פעימה ברקע לפני שתוקף התביעה פג (למשל, כל 3 עד 4 שניות בחלון תביעה של 10 שניות). כל טרנזקציית אות חיים מוחקת את הודעת הגיבוי הנוכחית (ActiveClaimId) באמצעותASSERT_ROWS_MODIFIED 1, מוסיפה הודעת גיבוי חדשה עםDeliverTimeעתידי מעודכן, ומעדכנת אתActiveClaimIdואתProcessingExpiresAtב-Customers. עוצרים את האות לפני שמתחילים את עסקה 2.
מכיוון ששלב 2 פועל מחוץ לטרנזקציה של מסד נתונים והתור מועבר לפחות פעם אחת, קריסה של ה-worker אחרי קריאה ל-API חיצוני גורמת ל-worker הבא לנסות שוב את המשימה. העברת מפתח אידמפוטנטיות דטרמיניסטי מאפשרת לשירות החיצוני להתעלם מבקשות כפולות. מידע נוסף זמין במאמר תיבת דואר יוצא של טרנזקציות.
החלפה תקופתית של הודעת הגיבוי והארכת ProcessingExpiresAt שומרות על תביעת הישות פעילה בזמן שה-worker תקין, ועדיין מאפשרות ל-worker אחר להשתלט אם ה-worker קורס.
לדוגמה, טרנזקציית האות הבאה מאריכה את התביעה הפעילה על הישות ב-10 שניות:
GoogleSQL
-- Run every 3 to 4 seconds on a 10-second claim window before starting Transaction 2:
DELETE FROM CustomerDirtyQueue
WHERE CustomerId = 456 AND MessageId = 'claim-uuid-2'
ASSERT_ROWS_MODIFIED 1;
INSERT INTO CustomerDirtyQueue (CustomerId, MessageId, DeliverTime, Payload)
VALUES (456, 'claim-uuid-3', TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 10 SECOND), b'');
UPDATE Customers
SET ActiveClaimId = 'claim-uuid-3',
ProcessingExpiresAt = TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 10 SECOND)
WHERE CustomerId = 456 AND ActiveClaimId = 'claim-uuid-2';
PostgreSQL
-- Run every 3 to 4 seconds on a 10-second claim window before starting Transaction 2:
DELETE FROM customerdirtyqueue
WHERE customerid = 456 AND messageid = 'claim-uuid-2'
ASSERT_ROWS_MODIFIED 1;
INSERT INTO customerdirtyqueue (customerid, messageid, deliver_time, payload)
VALUES (456, 'claim-uuid-3', CURRENT_TIMESTAMP + INTERVAL '10 SECOND', CAST('' AS bytea));
UPDATE customers
SET activeclaimid = 'claim-uuid-3',
processingexpiresat = CURRENT_TIMESTAMP + INTERVAL '10 SECOND'
WHERE customerid = 456 AND activeclaimid = 'claim-uuid-2';
איך להגדיל את קנה המידה של ישויות בנפח גבוה באמצעות פיצול וקריאות בעבר
כשיישות אחת מקבלת יותר פעולות כתיבה ממה שפיצול אחד של Spanner יכול לטפל בו, כתיבה של כל משימה בפיצול Customers אחד יוצרת נקודה חמה של כתיבה, גם אם עדיין צריך לעבד משימות של אותה ישות לפי סדר ה-commit.
כדי להגדיל את קצב העיבוד של פעולות הכתיבה של ישות בנפח גבוה תוך שמירה על הסדר הגלובלי, צריך לפזר את פעולות הכתיבה בין N פיצולים ולמזג אותם באופן אסינכרוני עם עובד ניקוי תקופתי באמצעות קריאות בעבר:
- פיצול טבלאות העבודה וביטול הכפילויות: יוצרים טבלת הורה
CustomerShardsעםPRIMARY KEY (ShardId, CustomerId)(ShardIdמ-0עדN - 1) ומשלבים טבלת עבודה מפוצלת עם מפתח(ShardId, CustomerId, CreatedAt, BatchIndex). הפיכתShardIdלעמודת המפתח המובילה מפזרת את פעולות הכתיבה על פניNפיצולים. כדי למנוע שורות כפולות של משימות כשעסקה שמנסים לבצע מחדש מקבלתPENDING_COMMIT_TIMESTAMP()חדש, צריך גם לשלב טבלת ביטול כפילויות באצווה עם מפתח לפי(ShardId, CustomerId, BatchId)עם מדיניות TTL. - ניתוב כל אצווה של יצרן למאגר נתונים אחד בלי כתיבה לתור: בכל טרנזקציה של יצרן, מחשבים את
ShardIdמגיבוב (hash) שלBatchIdייחודי (כמוFARM_FINGERPRINT) ומכניסים גם לטבלת ביטול הכפילויות וגם לטבלת העבודה של מאגר הנתונים, בלי להכניס לתור. גיבוב (hashing) שלBatchIdשומר כל טרנזקציה של יצרן בפיצול יחיד, ומבטל את התקורה של התור לכל כתיבה. - סריקת מקטעים לפי הסדר באמצעות קריאה בעבר וסמן התקדמות: שומרים על תביעה פעילה וסמן
(LastSweptAt, LastBatchIndex, LastShardId)בטבלתCustomerSweeperStateנפרדת עם תור התעוררות משולב, שמכיל הודעת סריקה חוזרת אחת לכל ישות. כשהוא מופעל, ה-worker תובע את הישות (באמצעות אותה תבנית של תביעה והודעת חלופית כמו ב-שימוש בטבלת עבודה מסודרת ובתור התעוררות), שולח שאילתות לכלNהשארדים אחרי הסמן באמצעות קריאה של התיישנות מדויקת של 10 שניות, מסודרת לפיCreatedAt ASC, BatchIndex ASC, ShardId ASC, מעבד את ה-batch לפי הסדר ומבצע טרנזקציית השלמה שמוחקת את השורות שעובדו, מקדמת את הסמן ומתזמנת את הסריקה הבאה. שימוש בקריאה בעבר מונע חסימה של כתיבות של יצרנים במהלך הפיצולים, והסמן מדלג על שורות שעובדו ונמחקו בחלון הזמן של הקריאה בעבר.