---
title: 'Rekabet Eden Tüketiciler'
source: 'https://academia.sh/tr/kurslar/uygulama-katmani/rekabet-eden-tuketiciler'
course: 'Uygulama Katmanı ve Servis Etkileşimi'
language: tr
updated: '2026-08-17T18:10:55+00:00'
license: 'CC BY-SA 4.0'
---

# Rekabet Eden Tüketiciler

Aynı kuyruktan çeken tüketici sayısının bir kapasite kararı olarak ölçülmesi: eklenen her tüketicinin boşalma süresine katkısının azalması, paylaşılan bir kaynağın koyduğu asimptotik tavanın hesaplanması, verim karşılığında bozulan gönderi sırasının ve yanlış kalan son durumun sayılması ve tavanın tek tüketiciden istenen hıza çevrilmesi.

Önceki dersin son satırındaki "4,00 işçi" bir kapasite değil bir alt sınırdı; doluluk bire eşit
olduğunda kuyruk boşalmaz. Sayının kendisi de bir soruyu açık bırakıyordu: işçi eklemek gerçekten
toplamaya karşılık gelir mi. İlk dersin birikme tablosunda tüketici kapasitesi tek bir sayıydı ve
o sayının nereden geldiği sorulmamıştı; oysa kapasite tüketici sayısıyla tüketici başına hızın
çarpımıdır ve çarpanlardan biri sonsuza kadar büyümez.

Bu ders o çarpımı ölçer. **Rekabet eden tüketiciler** (competing consumers), aynı kuyruktan çeken
ve her iletiyi yalnız birinin aldığı tüketici kümesidir. Önbellekleme, Kuyruklar ve Eşzamansız
İşleme kursunda aynı düzen kuruldu ve her iletinin tek tarafa gittiği
orada ölçüldü; kalıp aynı kalıptır, bu kursta kullanılan biçim katalog biçimidir. Orada kurulan
tüketici grupları ile buradaki fark bir cümleyle söylenebilir: grup, aynı iletinin kaç ayrı
tarafa **kopyalanacağını** belirler; rekabet eden tüketiciler tek bir tarafın işini kaç birime
**bölüneceğini** belirler. Bu dersin ölçüsü de bölmenin karşılığıdır: verim ile sıra arasındaki
ödünleşim.

## Bölünen İş ve Bölünmeyen Kaynak

Düzenek 5000 gönderinin durum olaylarını bir kuyruğa koyar. Gönderi başına olay sayısı K01'in V4
varsayımından gelir: 7. Toplam 35.000 olay. Aynı gönderinin ardışık olayları kuyruğa yan yana
düşer, çünkü taşıyıcı bir aktarımda birden çok tarama gönderir; bu, sıranın bozulabildiği tek
durumdur ve modelin ilgi alanıdır.

Tüketicilerin bölemeyeceği bir şey vardır: olayın etkisini yazdığı depo. Modelde bu, **depo
yuvası** adıyla bir parametredir — bir turda en fazla S olay uygulanabilir. **S ölçülmüş bir sayı
değildir**, model parametresidir; buradaki işi, tüketici sayısının tek başına bir kapasite
olmadığını görünür kılmaktır. İki değerle koşulur: S = 2 ve S = 4.

Tur soyut bir adımdır. Bir olayın işlenmesi tohumdan gelen 1–3 tur sürer; gönderinin son olayı
("teslim edildi") 6 tur sürer, çünkü fatura satırını da hazırlar. Bütün koşumlar aynı olay
dizisiyle karşılaşır, dolayısıyla sonuçlar belirlenimlidir ve makineden bağımsızdır.

```js
// rakip/tuketici.mjs — ayni kuyruktan ceken N tuketicinin bosalma suresine ve gonderilerin
// son durumuna etkisi. MODEL: tur soyut bir adimdir; depo yuvasi S bir model parametresidir.
// Sonuclar belirlenimlidir (hesap sinifi) ve makineden bagimsizdir.
const GONDERI = 5000;              // is yukundeki gonderi sayisi
const ADIM = 7;                    // K01 varsayim V4: gonderi basina durum olayi
const ARA = 1;                     // ayni gonderinin ardisik olaylari arasindaki kuyruk mesafesi
const TOHUM = 20260731;

function uretec(tohum) {
  let a = tohum >>> 0;
  return () => {
    a = (a + 0x9e3779b9) >>> 0;
    let z = Math.imul(a ^ (a >>> 16), 0x21f0aaad) >>> 0;
    z = Math.imul(z ^ (z >>> 15), 0x735a2d97) >>> 0;
    return ((z ^ (z >>> 15)) >>> 0) / 4294967296;
  };
}

function isYuku() {                // kuyruga dusme sirasina gore olay dizisi
  const r = uretec(TOHUM);
  const o = [];
  for (let g = 0; g < GONDERI; g += 1) {
    const bas = r() * GONDERI * ARA;
    for (let k = 0; k < ADIM; k += 1) {
      o.push({ g, k, t: bas + k * ARA + r() * ARA, sure: k === ADIM - 1 ? 6 : 1 + Math.floor(r() * 3) });
    }
  }
  return o.sort((a, b) => a.t - b.t);
}

function kosum(olaylar, N, S) {
  const tuketici = Array.from({ length: N }, () => null);
  const sonUygulanan = new Array(GONDERI).fill(-1);
  const bozulan = new Set();
  let sira = 0, tur = 0, uygulanan = 0;
  while (uygulanan < olaylar.length) {
    for (const c of tuketici) if (c && c.kalan > 0) c.kalan -= 1;
    let yuva = S;                  // depo yazma yuvasi: her tur en fazla S olay uygulanir
    for (let i = 0; i < N; i += 1) {
      const c = tuketici[i];
      if (c && c.kalan === 0 && yuva > 0) {
        yuva -= 1;
        if (c.is.k < sonUygulanan[c.is.g]) bozulan.add(c.is.g);
        sonUygulanan[c.is.g] = c.is.k;
        uygulanan += 1;
        tuketici[i] = null;
      }
    }
    for (let i = 0; i < N; i += 1) {
      if (tuketici[i] === null && sira < olaylar.length) {
        const is = olaylar[sira]; sira += 1;
        tuketici[i] = { is, kalan: is.sure };
      }
    }
    tur += 1;
  }
  const yanlisSon = sonUygulanan.filter((k) => k !== ADIM - 1).length;
  return { tur, bozulan: bozulan.size, yanlisSon, verim: olaylar.length / tur };
}

const olaylar = isYuku();
console.log(`is yuku: ${GONDERI} gonderi x ${ADIM} olay (V4) = ${olaylar.length} olay`);
console.log(`depo yuvasi S: turda en fazla S olay uygulanir (model parametresi)\n`);
for (const S of [2, 4]) {
  console.log(`S = ${S}`);
  console.log("  N  bosalma turu  hizlanma  ek tuketicinin katkisi  verim(olay/tur)  sirasi bozulan  yanlis son durum");
  let onceki = null;
  const taban = kosum(olaylar, 1, S).tur;
  for (const N of [1, 2, 3, 4, 6, 8]) {
    const r = kosum(olaylar, N, S);
    const h = taban / r.tur;
    const katki = onceki === null ? "-" : ((h - onceki.h) / (N - onceki.N)).toFixed(3);
    console.log(`${String(N).padStart(3)}  ${String(r.tur).padStart(12)}  ${h.toFixed(2).padStart(8)}  ` +
      `${katki.padStart(22)}  ${r.verim.toFixed(3).padStart(15)}  ${String(r.bozulan).padStart(14)}  ` +
      `${String(r.yanlisSon).padStart(17)}`);
    onceki = { h, N };
  }
  console.log();
}

const TEPE = 97.22;                // K01: tepe yazma istek/s
const ISLEME = 48.61;              // 01. dersin sectigi isleme kapasitesi (tepenin yarisi)
const tekVerim = kosum(olaylar, 1, 2).verim;
console.log(`K01 donusu: tepe yazma ${TEPE} olay/s, 01. dersin isleme kapasitesi ${ISLEME} olay/s`);
for (const S of [2, 4]) {
  const tavan = S / tekVerim;
  console.log(`  S = ${S}: asimptotik tavan ${tavan.toFixed(2)} tuketici -> tek tuketici en az ` +
    `${(ISLEME / tavan).toFixed(2)} olay/s (kuyruklu) / ${(TEPE / tavan).toFixed(2)} olay/s (eszamanli)`);
}
const a = kosum(olaylar, 6, 2), b = kosum(olaylar, 8, 2);
console.log(`  S = 2, N 6 -> 8: bosalma ${((b.tur / a.tur - 1) * 100).toFixed(1)}%, ` +
  `sirasi bozulan +${((b.bozulan / a.bozulan - 1) * 100).toFixed(0)}%, ` +
  `yanlis son durum ${a.yanlisSon} -> ${b.yanlisSon}`);
```

```
is yuku: 5000 gonderi x 7 olay (V4) = 35000 olay
depo yuvasi S: turda en fazla S olay uygulanir (model parametresi)

S = 2
  N  bosalma turu  hizlanma  ek tuketicinin katkisi  verim(olay/tur)  sirasi bozulan  yanlis son durum
  1         89972      1.00                       -            0.389               0                  0
  2         44987      2.00                   1.000            0.778             102                  0
  3         30620      2.94                   0.938            1.143             248                  0
  4         23845      3.77                   0.835            1.468             511                  0
  6         18470      4.87                   0.549            1.895            1590                 30
  8         17551      5.13                   0.128            1.994            2279                432

S = 4
  N  bosalma turu  hizlanma  ek tuketicinin katkisi  verim(olay/tur)  sirasi bozulan  yanlis son durum
  1         89972      1.00                       -            0.389               0                  0
  2         44987      2.00                   1.000            0.778             102                  0
  3         29993      3.00                   1.000            1.167             236                  0
  4         22496      4.00                   1.000            1.556             429                  0
  6         15099      5.96                   0.980            2.318             915                  0
  8         11591      7.76                   0.902            3.020            1543                  0

K01 donusu: tepe yazma 97.22 olay/s, 01. dersin isleme kapasitesi 48.61 olay/s
  S = 2: asimptotik tavan 5.14 tuketici -> tek tuketici en az 9.45 olay/s (kuyruklu) / 18.91 olay/s (eszamanli)
  S = 4: asimptotik tavan 10.28 tuketici -> tek tuketici en az 4.73 olay/s (kuyruklu) / 9.45 olay/s (eszamanli)
  S = 2, N 6 -> 8: bosalma -5.0%, sirasi bozulan +43%, yanlis son durum 30 -> 432
```

## Katkı Nerede Duruyor

"Ek tüketicinin katkısı" sütunu hızlanmanın tüketici başına artışını veriyor; birim katkı, eklenen
tüketicinin bir tüketicilik iş yaptığı anlamına gelir.

S = 2 sütununda katkı N = 2'de 1,000, N = 3'te 0,938, N = 4'te 0,835, N = 6'da 0,549 ve N = 8'de
0,128. Sekizinci tüketici birincinin sekizde birinden azını katıyor. Boşalma süresi 18.470 turdan
17.551 tura, yani yalnız yüzde 5 kısalıyor. Verim sütunu nedeni söylüyor: 1,994 olay/tur, yani
S = 2 sınırının kendisi. **Tüketici eklemek kuyruk tarafında bir karardır, ama tavanı kuyruğun
dışındaki bir kaynak koyar.**

S = 4 sütununda aynı tüketici sayıları farklı davranıyor: katkı N = 6'ya kadar 0,98'in üstünde
kalıyor ve N = 8'de 0,902. Hızlanma 7,76, verim 3,020 olay/tur. Tavan bu kez uzaktadır ve tüketici
eklemek hâlâ karşılığını veriyor. İki sütun arasındaki fark tek bir parametredir ve **kuyruk
tarafında hiçbir şey değişmemiştir**.

Tavanın kendisi hesaplanabilir. Tek tüketicinin verimi 0,389 olay/tur olduğuna göre asimptotik
hızlanma tavanı $S / 0{,}389$ olur: S = 2 için 5,14, S = 4 için 10,28 tüketici. Ölçülen 5,13 ve
7,76 değerleri bu tavanla tutarlıdır. Tasarım sonucu doğrudandır: **bir kuyruğun arkasına
konabilecek yararlı tüketici sayısının üst sınırı, tüketicilerin paylaştığı en dar kaynağın
kapasitesine bölünmüş tek tüketici hızıdır.**

## Verimin Karşılığında Bozulan

Sağdaki iki sütun ödenen bedeldir. "Sırası bozulan" bir gönderinin en az bir olayının kendisinden
sonraki bir olaydan **sonra** uygulanmasıdır; "yanlış son durum", gönderinin en son uygulanan
olayının yedinci adım olmamasıdır, yani gönderi kayıtta bitmiş görünmez.

Tek tüketicide ikisi de sıfırdır: kuyruk sırası uygulama sırasıdır. İkinci tüketiciyle 5000
gönderinin 102'sinin sırası bozuluyor. Dördüncüde 511, altıncıda 1590, sekizincide 2279 — yani
gönderilerin yüzde 45,6'sı. Bozulma tüketici sayısıyla birlikte hızlanarak artıyor, çünkü aynı
anda işlenen olay sayısı arttıkça aynı gönderinin iki olayının çakışma olasılığı artıyor.

İki sütunun ilişkisi dersin en önemli sonucudur. S = 4 ve N = 8'de 1543 gönderinin sırası
bozulduğu hâlde yanlış son durumda kalan gönderi **yoktur**. S = 2 ve N = 8'de ise 2279 bozulmanın
432'si yanlış son duruma dönüşüyor. Aradaki fark, son olayın altı tur sürmesi ve depo yuvası dar
olduğunda uygulanmasının gecikmesidir. Yani **sıra bozulmasının görünür bir hataya dönüşüp
dönüşmemesi, iş sürelerinin ve kaynak darlığının rastlantısına bağlıdır.** Bir tasarım bu
rastlantıya dayanamaz: yüklerin dağılımı değiştiğinde 0 olan sayı 432 olur.

Son satır bu ödünleşimi tek satıra indiriyor. S = 2 iken tüketici sayısını altıdan sekize
çıkarmak boşalma süresini yüzde 5 kısaltıyor, sırası bozulan gönderiyi yüzde 43 artırıyor ve
yanlış son durumda kalan gönderiyi 30'dan 432'ye çıkarıyor. **Kazanç yüzde beş, bedel on dört
kat.** Tavanın ötesindeki tüketiciler verim eklemez, yalnız bozulma ekler.

Sıranın korunması için kurulan çözüm — aynı anahtarın olaylarını aynı bölüme yönlendirmek —
Önbellekleme, Kuyruklar ve Eşzamansız İşleme kursunda kuruldu ve orada bölüm sayısının koşutluğa
ve anahtar içi sıraya etkisi ölçüldü. Burada tekrarlanmaz; bu dersin katkısı, sıra bozulmasının
**hangi tüketici sayısında hangi maliyete karşılık geldiğini** kapasite kararının yanına koymaktır.

## Hesaba Geri Dönüş

Tavan, K01'in sayılarına çevrildiğinde bir gereksinime dönüşür. İlk ders işleme kapasitesini
tepenin yarısında, 48,61 olay/s'de seçmişti; eşzamanlı tasarımda gereken 97,22 olay/s'ydi.

S = 2 iken grubun verebileceği en yüksek kapasite tek tüketicinin 5,14 katıdır. 48,61 olay/s'ye
ulaşmak için tek tüketicinin en az **9,45 olay/s** işlemesi gerekir; eşzamanlı tasarımın 97,22
olay/s'si için **18,91 olay/s**. Tek tüketici bunun altındaysa hiçbir tüketici sayısı yetmez ve
çözüm kuyruk tarafında değildir. S = 4 iken aynı eşikler 4,73 ve 9,45 olay/s'ye iner.

Buradan çıkan okuma kuralı şudur: bir kapasite hedefi "kaç tüketici" sorusuyla değil, **iki
sayının çarpımıyla** karşılanır ve çarpanlardan biri paylaşılan kaynağın kapasitesine bağlıdır.
Bir tasarım tartışmasında "tüketici ekleriz" cümlesi, tavan hesaplanmadan söylendiğinde bir çözüm
değil bir varsayımdır.

## Özet

- Rekabet eden tüketiciler tek bir tarafın işini kaç birime böleceğini belirler; tüketici grupları
  ise aynı iletinin kaç tarafa kopyalanacağını belirler.
- Eklenen tüketicinin katkısı azalıyor: S = 2'de N = 2'de 1,000, N = 4'te 0,835, N = 8'de 0,128;
  boşalma altıdan sekiz tüketiciye geçişte yalnız yüzde 5 kısalıyor.
- Tavanı kuyruk değil paylaşılan kaynak koyuyor: asimptotik hızlanma tavanı S = 2 için 5,14,
  S = 4 için 10,28 tüketicidir ve ölçülen 5,13 ile 7,76 bununla tutarlıdır.
- Sıra bozulması tüketici sayısıyla hızlanarak artıyor: 5000 gönderinin 102'si iki tüketicide,
  511'i dörtte, 2279'u sekizde bozuluyor.
- Bozulmanın görünür hataya dönüşmesi rastlantısaldır: S = 4 ve N = 8'de 1543 bozulmanın hiçbiri
  yanlış son durum üretmezken S = 2'de 2279 bozulmanın 432'si üretiyor.
- K01'e dönüş: 48,61 olay/s'lik işleme kapasitesi S = 2 iken tek tüketiciden en az 9,45 olay/s,
  S = 4 iken 4,73 olay/s ister; tek tüketici bunun altındaysa tüketici sayısı çözüm değildir.

## Sonraki Adım

Bu dersin iş yükü bir gün boyunca aynı hızda akan bir olay dizisiydi ve tüketici sayısı o hıza
göre seçildi. İlk dersin profili de aynı varsayımı taşıyordu: tepe biliniyor, ne zaman geleceği
biliniyor, süresi biliniyor. Gerçek bir akışta bu üçünün hiçbiri garanti değildir. Taşıyıcının
bağlantısı yirmi dakika koptuğunda hiçbir olay gelmez, sonra biriken her şey bir anda gelir ve o
anki hız günün tepesiyle ilgisiz olur. Sonraki ders bu ani yükü ele alır: kuyruğun yükü zamana
yaymasının önceden bilinmeyen bir tepede ne anlama geldiğini, tamponun ne kadar büyük olması
gerektiğini ve tampon yetmediğinde nelerin düştüğünü sayar.
