|
**Kuyruk motoru**
- `FOR UPDATE SKIP LOCKED` ile **yarışsız** rezervasyon
- Desteklenmeyen sürümde **otomatik** koşullu-UPDATE yedeği
- Yetenek tespiti sürüm dizgisine değil **davranışa** bakar
- Üstel geri çekilme (`10 → 20 → 40 …`, tavanlı)
- Görünürlük zaman aşımı: çöken worker'ın işi geri döner
- `attempts` rezervasyon anında artar (çökme de sayılır)
- Dead-letter ayrı tabloda; yeniden kuyruğa alma ve silme
- Çoklu kuyruk desteği (`default`, `mails`) — ayrı worker'lar için
- Gecikmeli iş: `available_at` tek sütunla iki işi birden yapar
- CLI worker: `--once`, `--max=N`, `--queue=…`, zarif kapanış (SIGTERM)
|
**Arayüz ve altyapı**
- Sayaç şeridi: hazır / gecikmeli / işleniyor / **bayat** / başarısız
- "Bayat rezerve" sayacı sıfırdan büyükse **uyarı rengine** geçer
- Worker günlüğü — terminal çıktısının ekrandaki karşılığı
- Otomatik mod (2 sn) ve tek adım tetikleme
- İş detayı: payload, zamanlar, `reserved_by`, son hata
- Paylaşılabilir derin bağlantı `#is-10`
- Bayat rezervasyonları elle serbest bırakma düğmesi
- Üç ayrı hız sınırı kovası (enqueue / work / status)
- Çift gönderim koruması, toast bildirimleri, `aria-live`
- Mobil: 767 / 480px eşikleri, **yatay kaydırma yok**
|
---
### Güvenlik: Neyi, Nasıl Kapattık?
| Açık | Tipik hatalı kod | Bu projede |
|------|------------------|------------|
| **Aynı işin iki kez çalışması** | `SELECT … LIMIT 1` sonra `UPDATE` | `FOR UPDATE SKIP LOCKED`; yedek yolda tek `UPDATE` + `rowCount()` kontrolü. Bu bir "performans iyileştirmesi" değil, **doğruluk** meselesidir |
| **SQL Injection** | `"… WHERE queue = '".$_POST['q']."'"` | Tüm sorgular prepared statement, `EMULATE_PREPARES = false`. Kuyruk adı ve iş türü **beyaz listeden** geçer (`KNOWN_QUEUES`, `KNOWN_JOBS`) |
| **XSS (kuyruk ekranında)** | `$('#row').html(job.type)` | İş türü, payload ve hata metni kullanıcı/dış servis verisidir. Sunucuda `e()`, istemcide `esc()` |
| **Worker'ın web'den çalıştırılması** | `bin/worker.php` erişilebilir | İki katman: dosyanın başında `PHP_SAPI !== 'cli'` kontrolü **ve** `.htaccess`'te `Require all denied` |
| **Sonsuz yeniden deneme** | `while (true) retry` | `JOB_MAX_ATTEMPTS` ve dead-letter. Kalıcı bir hata sonsuz bir maliyete dönüşmez |
| **Kaybolan iş (çöken worker)** | Sadece `reserved = 1` bayrağı | `reserved_at` + `RESERVE_TTL`. Sahipsiz kalan iş otomatik geri döner |
| **Yarım kalan durum geçişi** | Önce `INSERT`, sonra `DELETE` | Dead-letter'a taşıma ve yeniden kuyruğa alma **tek transaction**; iş asla iki yerde birden bulunmaz |
| **Bozuk kodlamanın yanıtı yutması** | `json_encode()` → `false` → boş gövde | `JSON_INVALID_UTF8_SUBSTITUTE`: dış servisten gelen bozuk bir bayt, kuyruğun tamamını görünmez yapmaz |
| **CSRF** | *(genelde hiç yok)* | Oturuma bağlı 32 baytlık token, **her** istekte, `hash_equals()` ile sabit zamanlı doğrulama |
| **Kaynak tüketimi** | Sınırsız `enqueue` | `ENQUEUE_MAX_COUNT` (25) ve **üç ayrı hız sınırı kovası**. `status` en sık, `work` en pahalı olandır |
| **Bilgi sızıntısı** | Ekrana basılan MySQL hataları | `APP_DEBUG` sunucu adından türetilir; canlıda otomatik `false`, detay `error_log()`'a gider |
| **Kurulum dosyasının indirilmesi** | `/cy_queue.sql` → HTTP 200 | `.htaccess`: `.sql`, `.md`, `.json`, `.log` … kapalı (README dosyaları bilinçli istisnadır) |
---
### Kurulum
> Sadece görmek istiyorsanız kurulum gerekmez → [**Canlı Demoyu açın**](https://cilginyazilim.com/kutuphane/uygulama/PHP-MySQL-Job-Queue-Is-Kuyrugu-PDO-Skip-Locked-Worker-main/). Aşağıdaki adımlar projeyi kendi bilgisayarınızda çalıştırmak içindir (~2 dakika).
#### Gereksinimler
- PHP **8.0+** (`pdo_mysql` eklentisi; zarif kapanış için `pcntl` — isteğe bağlı)
- **MySQL 8.0+** veya **MariaDB 10.6+** önerilir (`SKIP LOCKED` için)
Daha eski sürümlerde kod **kendiliğinden** yedek yola düşer; kurulum değişmez.
- Apache (XAMPP / WAMP / Laragon) — ya da PHP'nin yerleşik sunucusu
#### Adımlar
**1 — Projeyi indirin**
```bash
git clone https://github.com/CilginYazilim/PHP-MySQL-Job-Queue-Is-Kuyrugu-PDO-Skip-Locked-Worker.git
cd PHP-MySQL-Job-Queue-Is-Kuyrugu-PDO-Skip-Locked-Worker
```
**2 — Veritabanını oluşturun**
`cy_queue.sql` veritabanını da kendisi oluşturur.
```bash
mysql -u root -p < cy_queue.sql
```
**3 — Arayüzü açın**
```bash
php -S 127.0.0.1:8000
```
XAMPP kullanıyorsanız projeyi `htdocs` altına koyup şu adresi açın:
`http://localhost/PHP-MySQL-Job-Queue-Is-Kuyrugu-PDO-Skip-Locked-Worker/`
**4 — Worker'ı ayrı bir terminalde başlatın** *(isteğe bağlı ama asıl olan budur)*
```bash
php bin/worker.php
```
Arayüzdeki **▶ Worker'ı çalıştır** düğmesi de aynı işi yapar — ama tek adımda ve gözlem için.
---
### Worker'ı Çalıştırmak
```bash
php bin/worker.php # varsayılan kuyruk, süresiz
php bin/worker.php --once # tek iş işle ve çık
php bin/worker.php --max=50 # 50 iş işleyince çık
php bin/worker.php --queue=mails # başka bir kuyruk
```
#### Üretimde: süpervizör altında
Worker sürekli çalışan bir süreçtir ve **çökebilir**. Bir süpervizör onu yeniden başlatmalıdır. systemd örneği:
```ini
[Unit]
Description=CY Job Queue Worker
After=mysql.service
[Service]
ExecStart=/usr/bin/php /var/www/proje/bin/worker.php --queue=default
Restart=always
RestartSec=5
User=www-data
[Install]
WantedBy=multi-user.target
```
`--max=500` ile birlikte kullanmak da yaygındır: worker 500 iş sonra kendini kapatır, süpervizör yeniden başlatır. Bu, uzun süren PHP süreçlerinde bellek sızıntısı riskini sıfırlar.
#### Cron ile (süpervizör yoksa)
```cron
* * * * * cd /var/www/proje && php bin/worker.php --max=20 >> /var/log/cy-queue.log 2>&1
```
Dakikada bir çalışır, en fazla 20 iş işler ve çıkar. Paylaşımlı hostingde en pratik yoldur.
#### Zarif kapanış
`pcntl` eklentisi varsa worker `SIGTERM`/`SIGINT` aldığında **işlenen işi bitirir**, sonra çıkar. Deploy sırasında yarım kalan iş olmaz.
---
### Yapılandırma
Tüm ayarlar [system/config.php](system/config.php) içindedir.
| Sabit | Varsayılan | Ne işe yarar |
|-------|-----------|--------------|
| `JOB_MAX_ATTEMPTS` | `3` | Bu kadar denemeden sonra iş dead-letter'a taşınır |
| `BACKOFF_BASE` | `10` | İlk yeniden deneme beklemesi (saniye) |
| `BACKOFF_CAP` | `600` | Beklemenin üst sınırı — saatlere çıkmasın |
| `RESERVE_TTL` | `90` | Görünürlük zaman aşımı: çöken worker'ın işi bu süre sonra serbest kalır |
| `WORKER_SLEEP` | `3` | Kuyruk boşken worker'ın uykusu (sıfır olsaydı %100 CPU) |
| `KNOWN_JOBS` | 4 tür | Arayüzden eklenebilecek iş türleri (**beyaz liste**) |
| `KNOWN_QUEUES` | `default, mails` | İzin verilen kuyruk adları (**beyaz liste**) |
| `ENQUEUE_MAX_COUNT` | `25` | Tek seferde eklenebilecek en fazla iş |
| `RATE_LIMIT_*` | `[istek, saniye]` | enqueue / work / status için **ayrı** kovalar |
#### `RESERVE_TTL` nasıl seçilir?
**En uzun işinizin süresinden belirgin biçimde uzun** olmalıdır. Kısa seçerseniz, hâlâ çalışan bir worker'ın işi "bayat" sayılır ve **ikinci kez** alınır — tam da kaçındığınız şey olur.
30 saniyelik rapor işleriniz varsa `RESERVE_TTL = 300` makuldür. Emin değilseniz büyük tarafta hata yapın: geç fark edilen bir çökme, iki kez çalışan bir işten ucuzdur.
#### Şifreyi koda yazmayın
Bu projede ekstra bir sebep var: **worker ayrı bir süreçtir** ve aynı yapılandırmayı okur. Künyeyi iki yerde tutmak, birini güncelleyip diğerini unutmanın kesin yoludur.
```bash
cp system/config.local.php.example system/config.local.php
# sonra dört satırı doldurun
```
Öncelik sırası: **`config.local.php` → ortam değişkeni → yerel varsayılan.**
---
### Kendi Projenize Eklemek
**1 — İki tabloyu alın**
`jobs` ve `failed_jobs` iş türünüzden bağımsızdır; olduğu gibi kopyalayın. `idx_jobs_pick` indeksini **mutlaka** taşıyın: worker'ın her turda çalıştırdığı sorgu ona dayanır.
**2 — Kendi işleyicilerinizi yazın**
```php
// system/function.php
function run_job_handler(string $type, array $payload): string
{
return match ($type) {
'send_invoice' => handle_send_invoice($payload),
'sync_stock' => handle_sync_stock($payload),
default => throw new RuntimeException("Bilinmeyen iş türü: $type"),
};
}
```
İşleyici **başarıda bir metin döndürür, hatada exception fırlatır.** Motor gerisini yapar: exception yakalanır, `attempts` kontrol edilir, ya backoff ile geri bırakılır ya dead-letter'a taşınır.
**3 — Kodunuzdan iş ekleyin**
```php
enqueue($db, 'send_invoice', ['order_id' => 4271], 'default', 0);
enqueue($db, 'sync_stock', ['sku' => 'ABC-1'], 'default', 300); // 5 dk sonra
```
**4 — Worker'ı süpervizör altına alın**
Yukarıdaki systemd birimi ya da cron satırı.
> **Atlamayın:** İşleyicileriniz **idempotent** olmalıdır — aynı iş iki kez çalışsa bile sonuç aynı olmalı. `SKIP LOCKED` yarışı kapatır, ama worker işi bitirip `complete_job()` çağırmadan hemen önce çökerse iş yeniden alınır. Dağıtık sistemlerde "tam bir kez" garantisi yoktur; "en az bir kez" vardır.
---
### Çılgın Yazılım Tasarım Kalıbı
[assets/css/cilginyazilim.css](assets/css/cilginyazilim.css) dosyası bu projeye değil **markaya** aittir. Bu örneğe özgü her şey (sayaç şeridi, durum rozetleri, worker günlüğü) [assets/css/style.css](assets/css/style.css) içindedir.
#### Hazır bileşenler
| Sınıf | Ne işe yarar |
|-------|--------------|
| `.cy-card` / `.cy-card__header` / `__body` / `__footer` | Gradyan başlıklı ana kart |
| `.cy-brand` / `.cy-brand__mark` / `__title` / `__subtitle` | Logo kutusu + başlık bloğu |
| `.cy-btn` + `--primary` \| `--onbrand` \| `--glass` | Marka butonları |
| `.cy-badge` + `--glass` \| `--soft` | Rozetler |
| `.cy-table` | Marka görünümlü tablo |
| `.cy-modal` / `.cy-detail` | Gradyan başlıklı modal ve etiket/değer listesi |
| `.cy-toast` + `--success` \| `--danger` \| `--info` | Bildirim balonları |
**Bu örneğe özgü** (`style.css`): `.cy-stats` / `.cy-stat`, `.cy-state--ready|delayed|reserved|stale|failed`, `.cy-log`, `.cy-panel`, `.cy-worker`, `.cy-switch`, `.cy-attempts`, `.cy-warn-dot`.
#### Renkleri değiştirmek
```css
:root {
--cy-brand-900: #061321; /* Logodaki en koyu lacivert */
--cy-brand-600: #0b5cb5; /* Ana marka mavisi */
--cy-accent: #0ea5e9; /* Vurgu rengi */
--cy-gradient: linear-gradient(135deg, #061321, #0b5cb5 45%, #0284c7);
}
```
#### Koyu tema
Kullanıcının işletim sistemi koyu temadaysa **otomatik** devreye girer. Zorlamak isterseniz: ``
---
### Dosya Yapısı
```
job-queue/
├── index.php → Arayüz. Veritabanına DOKUNMAZ; üç kart + bir modal.
├── cy_queue.sql → Şema + 13 iş + 4 dead-letter kaydı (NOW() ± INTERVAL)
├── .htaccess → Dizin listeleme kapalı, .sql/.md kapalı, bin/ kapalı
│
├── bin/
│ └── worker.php → CLI worker. Web'den çalıştırılamaz (iki katman koruma).
│
├── system/
│ ├── config.php → Ayarlar, PDO bağlantısı, APP_DEBUG türetimi
│ ├── config.local.php → (siz oluşturursunuz) canlı künye — .gitignore'da
│ ├── config.local.php.example
│ ├── function.php → KUYRUK MOTORU: enqueue, reserve, complete, release, fail
│ ├── ajax.php → 8 uç nokta
│ └── .htaccess → BEYAZ LİSTE: yalnızca ajax.php dışarıya açık
│
├── assets/
│ ├── css/
│ │ ├── cilginyazilim.css → MARKA KALIBI (projeler arası ortak — dokunmayın)
│ │ ├── style.css → Yalnızca bu örneğe özgü stiller
│ │ └── bootstrap.min.css
│ ├── js/
│ │ ├── queue.js → Sayaçlar, tetikleme, dead-letter, modal (6 bölüm)
│ │ ├── jquery-3.7.0.js
│ │ └── bootstrap.bundle.js
│ └── images/logo.png
│
├── docs/screenshots/
├── CHANGELOG.md
├── README.md · README.en.md
└── LICENSE → MIT
```
---
### Nasıl Çalışıyor?
```
enqueue($db, 'send_email', […], 'default', 0)
│
▼
┌────────────────────────────────────────────────────────┐
│ jobs │
│ available_at = NOW() + gecikme │
│ reserved_at = NULL │
│ attempts = 0 │
└────────────────────────────────────────────────────────┘
│
worker: reserve_job() ▼
┌────────────────────────────────────────────────────────┐
│ BEGIN │
│ SELECT id … FOR UPDATE SKIP LOCKED ← yarış YOK │
│ WHERE available_at <= NOW() │
│ AND (reserved_at IS NULL │
│ OR reserved_at < NOW() - RESERVE_TTL) │
│ UPDATE reserved_at = NOW(), attempts = attempts + 1 │
│ COMMIT │
└────────────────────────────────────────────────────────┘
│
run_job_handler($type, $payload)
│
┌───────────────────┴───────────────────┐
başarı exception
│ │
▼ ▼
complete_job() attempts < JOB_MAX_ATTEMPTS ?
satır SİLİNİR │ │
evet hayır
│ │
▼ ▼
release_job() fail_job()
reserved_at = NULL failed_jobs'a TAŞI
available_at = NOW() jobs'tan SİL
+ backoff(attempts) (tek transaction)
```
#### Sorumluluk dağılımı
| Katman | Dosya | Sorumluluk |
|--------|-------|-----------|
| Sunum | `index.php` | Yalnızca HTML iskeleti. Veri yok, sorgu yok. |
| Arayüz mantığı | `assets/js/queue.js` | Sayaçlar, tetikleme, otomatik mod, modal |
| Uç noktalar | `system/ajax.php` | İstek doğrulama, beyaz listeler, JSON yanıtı |
| **Kuyruk motoru** | `system/function.php` | Rezervasyon, backoff, dead-letter — **asıl iş burada** |
| Worker | `bin/worker.php` | Döngü, sinyal yönetimi, konsol çıktısı |
| Ayar | `system/config.php` | Sabitler, PDO, `APP_DEBUG` türetimi |
> Dikkat: `bin/worker.php` ile arayüzdeki düğme **aynı** `process_one()` fonksiyonunu çağırır. İki ayrı işleme kodu yazılsaydı, ikisi zamanla ayrışır ve "arayüzde çalışıyor ama worker'da çalışmıyor" durumu doğardı.
---
### AJAX API Referansı
Tüm istekler `system/ajax.php` adresine **POST** ile gider ve **CSRF token** taşır.
## Veritabanı Tabanlı İş Kuyruğu
#### PHP PDO · MySQL SKIP LOCKED · Worker · Bootstrap 5 · Çılgın Yazılım Tasarım Kalıbı
**Redis yok, RabbitMQ yok — sadece MySQL. Ama doğru yapılmış hâli.**
[](https://php.net)
[](https://mysql.com)
[](https://getbootstrap.com)
[](#kurulum)
[](LICENSE)
**🇹🇷 Türkçe** · [🇬🇧 English](README.en.md)
[**▶ Canlı Demo**](https://cilginyazilim.com/kutuphane/uygulama/PHP-MySQL-Job-Queue-Is-Kuyrugu-PDO-Skip-Locked-Worker-main/) · [Kaynak Kütüphanesi](https://cilginyazilim.com/kutuphane/php-job-queue) · [cilginyazilim.com](https://cilginyazilim.com)
---
### Canlı Demo
**Kurulum yok, kayıt yok, indirme yok — tarayıcınızdan 3 saniyede deneyin.**
▲ Görsele tıklayarak demoyu açabilirsiniz
---
### Beş Kritik Karar
#### 1) `FOR UPDATE SKIP LOCKED` — yarışı kapatan tek satır
Klasik "önce SELECT, sonra UPDATE" kalıbının arasında bir pencere vardır ve iki worker o pencereye aynı anda girer. `SKIP LOCKED` bu pencereyi **sıfırlar**: satırı okurken kilitler ve başka bir worker'ın kilitlediği satırı **beklemeden atlar**.
```sql
SELECT id FROM jobs
WHERE queue = :q
AND available_at <= NOW()
AND (reserved_at IS NULL OR reserved_at < (NOW() - INTERVAL :ttl SECOND))
ORDER BY id ASC
LIMIT 1
FOR UPDATE SKIP LOCKED
```
`SKIP LOCKED` olmadan `FOR UPDATE` de doğru çalışır ama **beklemeli**: ikinci worker, birincisi işini bitirene kadar durur. On worker'la kuyruk tek şeritli bir yola döner. `SKIP LOCKED` her worker'a "meşgul olanı atla, sıradakini al" dedirtir.
#### 2) Eski sürümler için yedek yol — sürüme değil davranışa bakmak
`SKIP LOCKED` MySQL 8.0 ve MariaDB 10.6 ile geldi. XAMPP uzun süre MariaDB 10.4 ile dağıtıldı; orada bu sözdizimi 1064 verir.
Sürüm dizgisini ayrıştırmak (`"10.4.32-MariaDB"` gibi bir metni parçalamak) kırılgandır — dağıtımlar kendi eklerini koyar. Onun yerine **sorguyu bir kez deniyoruz** ve sonucu hatırlıyoruz:
```php
function supports_skip_locked(PDO $db): bool
{
static $supported = null;
if ($supported !== null) { return $supported; }
try {
$db->beginTransaction();
$db->query('SELECT id FROM jobs LIMIT 0 FOR UPDATE SKIP LOCKED');
$db->commit();
$supported = true;
} catch (Throwable $e) {
if ($db->inTransaction()) { $db->rollBack(); }
$supported = false;
}
return $supported;
}
```
Yedek yol kilit yerine **koşullu güncelleme** kullanır. Numara şudur: rezervasyon ile sahiplik iddiası **tek bir `UPDATE`** içinde yapılır ve `WHERE` koşulu "hâlâ rezerve edilmemiş" der:
```php
UPDATE jobs SET reserved_at = NOW(), reserved_by = :stamp, attempts = attempts + 1
WHERE queue = :q AND available_at <= NOW()
AND (reserved_at IS NULL OR reserved_at < (NOW() - INTERVAL :ttl SECOND))
ORDER BY id ASC LIMIT 1
```
`rowCount() === 1` ise iş bizimdir; `0` ise başkası kapmıştır. `:stamp` benzersiz bir damgadır (`hostname:pid#rastgele`) — "benim satırımı geri oku" sorgusunu mümkün kılan şey odur.
#### 3) `available_at` tek sütunla iki işi birden yapar
Gecikmeli iş ("yarın gönder") ve yeniden deneme beklemesi (backoff) aynı soruyu sorar: *bu iş ne zaman işlenebilir?* İkisi için ayrı sütun tutmak (`delay_until` + `retry_at`) gereksizdir ve hangisinin geçerli olduğunu her sorguda karar vermeyi gerektirir.
```php
function backoff_seconds(int $attempts): int
{
return (int) min(BACKOFF_BASE * (2 ** max(0, $attempts - 1)), BACKOFF_CAP);
}
```
**Neden üstel:** sabit aralıkla yeniden denemek, geçici olarak çökmüş bir servise saniyede bir vurmak demektir — toparlanmasını engellersiniz. Üstel geri çekilme baskıyı kendiliğinden azaltır. `BACKOFF_CAP` ise beklemenin saatlere çıkmasını önler.
#### 4) Görünürlük zaman aşımı — çöken worker'ın işi kaybolmaz
Bir worker işi rezerve edip çökerse (elektrik, OOM, deploy) o iş sonsuza dek "işleniyor" durumunda kalır. Kimse işlemez, kimse fark etmez.
Çözüm `reserved_at` sütununun **eskiliğine** bakmaktır:
```sql
AND (reserved_at IS NULL OR reserved_at < (NOW() - INTERVAL 90 SECOND))
```
Bu tek koşul, "serbest" ile "rezerve ama sahibi kayıp" durumlarını aynı sorguda toplar. Demoda o durum ekranda **ayrı bir sayaç** olarak durur — çünkü sıfırdan büyükse bir sorun var demektir.
İkinci bir incelik: `attempts` **rezervasyon anında** artar, işin sonunda değil. Çöken bir worker'ın işi de bir denemeyi tüketmiş sayılır; yoksa sürekli çöken bir işleyici o işi sonsuza dek döndürürdü.
#### 5) Dead-letter ayrı bir tablodur
Başarısız işleri `jobs` tablosunda bir `status` sütunuyla tutmak cazip görünür. İki sebeple yanlıştır:
- `jobs`, worker'ın **her turda taradığı** tablodur ve küçük kalmalıdır. Asla işlenmeyecek satırlar orada birikirse her rezervasyon sorgusu yavaşlar.
- Başarısız iş artık bir **kuyruk kaydı** değil, bir **inceleme kaydıdır**. Farklı bir yaşam döngüsü vardır: insan bakar, düzeltir, yeniden kuyruğa alır ya da siler.
Demodaki dead-letter kayıtları bilerek farklı hata türleri taşır: geçici bir aksaklık (yeniden denemek mantıklı), geçersiz bir e-posta adresi (kalıcı — aynı sonucu verir) ve bilinmeyen bir iş türü (kodda o handler yok). **"Yeniden dene" düğmesine basmadan önce hata metnini okumak gerekir.**
---
### Neler Var?
**[cilginyazilim.com](https://cilginyazilim.com)** tarafından ❤ ile geliştirildi
## Sık Sorulan Sorular
### Neden Redis ya da RabbitMQ değil?
Çünkü çoğu proje için gerekmiyor. Zaten bir veritabanınız var; yedekleniyor, izleniyor ve ekibiniz onu biliyor. İkinci bir servis eklemek kurulum, yedekleme, izleme, sürüm yükseltme ve bir arıza noktası daha demektir. MySQL kuyruğu dakikada birkaç bin iş ve birkaç worker ile rahat gider. Ayrıca küçümsenmemesi gereken bir avantajı vardır: işi ekleyen transaction ile aynı transaction içinde kuyruğa koyabilirsiniz; sipariş kaydı geri alınırsa e-posta işi de geri alınır.
### SKIP LOCKED olmadan gerçekten iki worker aynı işi alır mı?
Evet, ve bu testte asla görünmeyen hatalardandır çünkü tek worker ile hiç oluşmaz. Klasik kalıpta SELECT ile UPDATE arasında bir pencere vardır; iki worker aynı milisaniyede SELECT yaparsa ikisi de aynı kaydı görür, ikisi de rezerve eder ve iş iki kez çalışır. Kullanıcı e-postayı iki kez alır ya da ödeme iki kez çekilir. Bu projede yedek yol bile bu pencereyi kapatır: rezervasyon ve sahiplik iddiası tek bir UPDATE içindedir ve WHERE koşulu hâlâ rezerve edilmemiş olmayı şart koşar.
### İşim iki kez çalışabilir mi? Tam bir kez garantisi var mı?
Yoktur ve hiçbir dağıtık kuyrukta yoktur. Worker işi bitirip tamamlandı işaretini koymadan hemen önce çökerse, iş görünürlük zaman aşımı sonrası yeniden alınır ve ikinci kez çalışır. Bu yüzden işleyicileriniz idempotent olmalıdır: aynı iş iki kez çalışsa bile sonuç aynı olmalı. Pratikte bu, bu siparişin faturası zaten gönderildi mi kontrolü ya da bir benzersiz indeks demektir. Kuyruğun garantisi en az bir kezdir; tam bir kez davranışını uygulama katmanı üretir.
### Görünürlük zaman aşımı değerini nasıl seçerim?
En uzun işinizin süresinden belirgin biçimde uzun olmalıdır. Kısa seçerseniz hâlâ çalışan bir worker'ın işi bayat sayılır ve ikinci kez alınır; tam da kaçındığınız şey olur. Otuz saniyelik rapor işleriniz varsa üç yüz saniye makuldür. Emin değilseniz büyük tarafta hata yapın: geç fark edilen bir çökme, iki kez çalışan bir işten ucuzdur.
### Kuyruk tablosu şişer mi, temizlik gerekir mi?
Kuyruk tablosu şişmez çünkü tamamlanan iş silinir; bu bilinçli bir karardır, worker'ın her turda taradığı tablo küçük kalmalıdır. Başarısız işler tablosu ise büyür; orada bir saklama politikası belirleyin, örneğin otuz günden eski kayıtları arşivleyin. Silmeden önce okuyun: dead-letter, sisteminizin nerede kırıldığını anlatan en dürüst kayıttır.
### Arayüzdeki worker düğmesi üretimde de kullanılabilir mi?
Hayır. O düğme bir işi web isteğinin içinde çalıştırır ve istek, işin süresi kadar bekler; kuyruğun var olma sebebi tam olarak bunu önlemektir. Düğme demoda iki iş görür: kuyruğun davranışını adım adım izletmek ve bir işi istek içinde çalıştırmanın neden kötü fikir olduğunu hissettirmek. Gerçek kurulumda worker bir süpervizör altında sürekli çalışır ya da cron ile dakikada bir tetiklenir.
---
Kaynak: [Veritabanı Tabanlı İş Kuyruğu](https://cilginyazilim.com/kutuphane/php-job-queue)