---
title: 'Devre Kesici'
source: 'https://academia.sh/tr/kurslar/dayaniklilik-kaliplari/devre-kesici'
course: 'Dayanıklılık ve Güvenilirlik'
language: tr
updated: '2026-08-17T18:11:00+00:00'
license: 'CC BY-SA 4.0'
---

# Devre Kesici

Bozuk bağımlılığın devreden çıkarılması: kesicinin servisler arasında paylaşılan yuva havuzunu koruması, eşiğin arıza kipine göre seçilmesi, ardışık sayı ile pencere oranı kurallarının dört kipte karşılaştırılması, açık durumda tasarruf edilen çağrı ile kurtarılan komşu isteğin sayılması ve sağlıklı bir bağımlılığı kesen yanlış açılmanın reddedilen geçerli istek cinsinden bedeli.

Önceki ders bir yön bıraktı: yavaşlayan bir bağımlılığı çağırmayı bırakmak yavaşlamayı durmaya
çevirir ve bulaşmayı 513,89 istek/s'den 97,22 istek/s'ye indirir. Bu dersin işi o cümleyi bir
bileşene dönüştürmek ve gerçekten öyle olup olmadığını aynı arıza senaryosunda ölçmektir.

**Devre kesici**, bir bağımlılığın son çağrılarının sonucuna bakarak o bağımlılığa yapılan çağrıyı
bir süre için hiç yapmayan bileşendir. Üç durumu vardır ve bu durumlar Uygulama Mimarisi kursunda
kuruldu: **kapalı** durumda çağrı geçer, **açık** durumda çağrı hiç yapılmaz ve çağıran anında
başarısızlık alır, **yarı açık** durumda tek bir yoklama çağrısı geçirilir ve sonucuna göre ya
kapalıya dönülür ya yeniden açılır. Geçiş mekaniği burada yeniden anlatılmaz.

Servisler arasında değişen üç şey vardır. Birincisi, kesicinin koruduğu kaynak çağıranın **yuva
havuzudur** ve o havuz başka akışlarla paylaşılır — kesici bozuk bağımlılığı değil, onunla aynı
havuzu kullanan akışları korur. İkincisi, eşik bir tercih değil **arıza kipine bağlı bir seçimdir**;
aynı eşik durmada ucuz, yavaşlamada pahalı, kısmi arızada yanlıştır. Üçüncüsü, açık durumda
reddedilen istekler gerçek isteklerdir ve bir yere gitmek zorundadır.

## Kesicisiz ve Kesicili Aynı Senaryo

Aşağıdaki koşum 01. dersin modelini turlara açar. Yuva havuzu ağ geçidindedir ve takip sorgusuyla
durum olayı arasında paylaşılır; bağımlılığın kipi parametredir. Yine bir **modeldir** — gerçek
küme, kapsayıcı ya da kaos aracı kurulmaz, rastgelelik tohumlu bir üreteçtendir.

**AY5 — kesicinin kuralı: son 20 çağrının 0,50'si başarısızsa aç, 100 tur (1 saniye) kesik kal.**
Gerekçe: 20 çağrı, taşıyıcı olay hızında yaklaşık 20 turluk bir penceredir, yani K01'in okuma eşiği
kadar; 0,50 eşiği kısmi arızanın 0,125'lik başarısızlık oranı ile durma ve yavaşlamanın 1,000'i
arasında durur. Duyarlılığı kesik süresi 200 tur ile aşağıda basılır.

```js
// kesici/kosum.mjs — ayni ariza senaryosunun kesicisiz ve kesicili kosumu. MODELDIR: tur soyut bir
// adim, ag gecidinin yuva havuzu iki akis arasinda paylasilir, bagimliligin kipi parametredir.
const YUVA = 32, CEVRIM = 100, T = 1200, BAS = 200;   // AY2, AY1; 12 s kosum, ariza 2. saniyede
const TAKIP = 416.67, OLAY = 97.22, TAKIP_TUTUS = 4;  // K01 tepe hizlari; 01. ders: takip bacagi 4 tur
const KIP = {                                         // p: cagrinin basarisizlik olasiligi
  saglikli: { p: 0.025, ok: 6, hata: 22 },            // AY4: seyrek zaman asimi, yuvayi 22 tur tutar
  kismi: { p: 0.125, ok: 6, hata: 3 },                // sekiz parcanin biri: hizli hata
  durma: { p: 1, ok: 6, hata: 3 },
  yavaslama: { p: 1, ok: 6, hata: 22 },
};

function kosum({ kip, kural }) {
  let s = 20260731 % 2147483647;
  const rast = () => (s = (s * 48271) % 2147483647) / 2147483647;
  const serbest = new Array(YUVA).fill(0);
  const c = { takipYanit: 0, takipYuvasiz: 0, olayYanit: 0, olayRed: 0, olayHata: 0, olayYuvasiz: 0,
    cagri: 0, olayYuvaTur: 0, acilma: 0, algilamaTur: null, algilamaYuvaTur: null };
  let birikT = 0, birikO = 0, durum = "kapali", ardisik = 0, acikBitis = 0, pencere = [], basY = 0;

  const yuvaAl = (t, sure) => {
    const i = serbest.findIndex((x) => x <= t);
    if (i < 0) return false;
    serbest[i] = t + sure; return true;
  };
  const acildi = (t) => {                     // kesici kapalidan acige gectiginde
    c.acilma += 1; durum = "acik"; acikBitis = t + kural.kesik; ardisik = 0; pencere = [];
    if (c.algilamaTur === null && t >= BAS && kip !== "saglikli") { c.algilamaTur = t - BAS; c.algilamaYuvaTur = c.olayYuvaTur - basY; }
  };

  for (let t = 0; t < T; t += 1) {
    if (t === BAS) basY = c.olayYuvaTur;
    if (durum === "acik" && t >= acikBitis) durum = "yariAcik";
    birikT += TAKIP / CEVRIM; birikO += OLAY / CEVRIM;
    const gelen = [];                          // turun icindeki varislar karistirilir (tohumlu)
    for (let n = Math.floor(birikT); n > 0; n -= 1, birikT -= 1) gelen.push("takip");
    for (let n = Math.floor(birikO); n > 0; n -= 1, birikO -= 1) gelen.push("olay");
    for (let i = gelen.length - 1; i > 0; i -= 1) {
      const j = Math.floor(rast() * (i + 1));
      [gelen[i], gelen[j]] = [gelen[j], gelen[i]];
    }

    for (const akis of gelen) {
      if (akis === "takip") { if (yuvaAl(t, TAKIP_TUTUS)) c.takipYanit += 1; else c.takipYuvasiz += 1; continue; }
      if (durum === "acik") { c.olayRed += 1; yuvaAl(t, 1); continue; }   // kesik: cagri hic yapilmaz
      const k = KIP[kip === "saglikli" || t < BAS ? "saglikli" : kip];
      const basarisiz = rast() < k.p;
      const sure = basarisiz ? k.hata : k.ok;
      if (yuvaAl(t, sure) === false) { c.olayYuvasiz += 1; continue; }
      c.cagri += 1; c.olayYuvaTur += sure;
      if (basarisiz) c.olayHata += 1; else c.olayYanit += 1;
      if (kural === null) continue;                    // kalipsiz kosum: durum tutulmaz
      if (durum === "yariAcik") { if (basarisiz) acildi(t); else { durum = "kapali"; ardisik = 0; pencere = []; } continue; }
      if (kural.tur === "ardisik") {
        ardisik = basarisiz ? ardisik + 1 : 0;
        if (ardisik >= kural.esik) acildi(t);
      } else {
        pencere.push(basarisiz ? 1 : 0);
        if (pencere.length > kural.pencere) pencere.shift();
        if (pencere.length === kural.pencere &&
          pencere.reduce((a, x) => a + x, 0) / kural.pencere >= kural.esik) acildi(t);
      }
    }
  }
  return c;
}

const ORAN = { tur: "oran", pencere: 20, esik: 0.5, kesik: 100 };   // AY5
const b = (x) => x.toFixed(2);
const OLCUT = ["takipYanit", "takipYuvasiz", "olayYanit", "olayRed", "olayHata", "cagri", "olayYuvaTur"];
const BASLIK = ["takip yanit", "takip yuvasiz", "olay yanit", "olay red", "olay hata", "yapilan cagri", "olay yuva-tur"];

console.log(`model: ${T} tur (${T / CEVRIM} s), ariza ${BAS}. turda, ${YUVA} yuva; secilen kural: son ` +
  `${ORAN.pencere} cagrinin ${ORAN.esik}'si basarisizsa ac, ${ORAN.kesik} tur kesik kal`);
console.log(`\n${"kosum".padEnd(24)}` + BASLIK.map((x) => x.padStart(15)).join(""));
const r = {};
for (const kip of ["saglikli", "kismi", "yavaslama", "durma"])
  for (const [ek, kural] of [["kesicisiz", null], ["kesicili", ORAN]]) {
    const ad = `${kip}, ${ek}`;
    r[ad] = kosum({ kip, kural });
    console.log(`${ad.padEnd(24)}` + OLCUT.map((k) => String(r[ad][k]).padStart(15)).join(""));
  }

const s1 = r["saglikli, kesicili"];
const [k0, k1] = [r["kismi, kesicisiz"], r["kismi, kesicili"]];
const [y0, y1] = [r["yavaslama, kesicisiz"], r["yavaslama, kesicili"]];
const [d0, d1] = [r["durma, kesicisiz"], r["durma, kesicili"]];
const olcek = (600 * CEVRIM) / (T - BAS);          // AY3: 10 dakikalik arizaya olcekleme
console.log(`\narizasiz gunun bedeli: ${s1.cagri} cagrinin hepsinde kesici sorgulanir ve ` +
  `${ORAN.pencere} kayitlik pencere tutulur; ${s1.acilma} yanlis acilma, ${s1.olayRed} reddedilen gecerli olay; ` +
  `kismi arizada ${k1.acilma} acilma ve olay yanit ${k0.olayYanit} -> ${k1.olayYanit} ` +
  `(${k0.olayYanit - k1.olayYanit} basarili olabilecek olay reddedildi)`);
console.log(`arizali gunun kazanci (yavaslama): takip yuvasiz ${y0.takipYuvasiz} -> ${y1.takipYuvasiz}, ` +
  `olay yuva-tur ${y0.olayYuvaTur} -> ${y1.olayYuvaTur} (%${b((100 * (y0.olayYuvaTur - y1.olayYuvaTur)) / y0.olayYuvaTur)} az), ` +
  `bozuk bagimliliga cagri ${y0.cagri} -> ${y1.cagri}`);
console.log(`ayni kazanc durmada: takip yuvasiz ${d0.takipYuvasiz} -> ${d1.takipYuvasiz}, ` +
  `olay yuva-tur ${d0.olayYuvaTur} -> ${d1.olayYuvaTur}, cagri ${d0.cagri} -> ${d1.cagri}`);
console.log(`AY3'un 10 dakikasina olcek: yavaslamada tasarruf edilen cagri ` +
  `${((y0.cagri - y1.cagri) * olcek).toFixed(0)}, kurtarilan takip istegi ` +
  `${((y0.takipYuvasiz - y1.takipYuvasiz) * olcek).toFixed(0)}`);

console.log(`\n${"kural".padEnd(18)}${"kip".padEnd(11)}${"algilama turu".padStart(14)}` +
  `${"algilamaya kadar yuva-tur".padStart(26)}${"acilma".padStart(8)}${"reddedilen gecerli olay".padStart(25)}`);
const KURAL = [
  ["ardisik 5", { tur: "ardisik", esik: 5, kesik: 100 }],
  ["oran 0,50 / 20", { tur: "oran", pencere: 20, esik: 0.5, kesik: 100 }],
  ["oran 0,10 / 20", { tur: "oran", pencere: 20, esik: 0.1, kesik: 100 }],
];
for (const [ad, kural] of KURAL)
  for (const kip of ["saglikli", "kismi", "yavaslama", "durma"]) {
    const k = kosum({ kip, kural });
    const kayip = kip === "kismi" ? k0.olayYanit - k.olayYanit : k.olayRed;
    console.log(`${ad.padEnd(18)}${kip.padEnd(11)}${String(k.algilamaTur ?? "-").padStart(14)}` +
      `${String(k.algilamaYuvaTur ?? "-").padStart(26)}${String(k.acilma).padStart(8)}` +
      `${String(kip === "saglikli" || kip === "kismi" ? kayip : "-").padStart(25)}`);
  }
const uzun = { ...ORAN, kesik: 200 }, dar = { tur: "oran", pencere: 20, esik: 0.1, kesik: 200 };
console.log(`duyarlilik: kesik suresi ${ORAN.kesik} yerine ${uzun.kesik} tur olsaydi yavaslamada yapilan ` +
  `cagri ${y1.cagri} -> ${kosum({ kip: "yavaslama", kural: uzun }).cagri}; oran 0,10 kuralinda arizasiz ` +
  `gunde reddedilen gecerli olay ${kosum({ kip: "saglikli", kural: KURAL[2][1] }).olayRed} -> ` +
  `${kosum({ kip: "saglikli", kural: dar }).olayRed}`);
```

```
model: 1200 tur (12 s), ariza 200. turda, 32 yuva; secilen kural: son 20 cagrinin 0.5'si basarisizsa ac, 100 tur kesik kal

kosum                       takip yanit  takip yuvasiz     olay yanit       olay red      olay hata  yapilan cagri  olay yuva-tur
saglikli, kesicisiz                5000              0           1135              0             31           1166           7492
saglikli, kesicili                 5000              0           1135              0             31           1166           7492
kismi, kesicisiz                   5000              0           1021              0            145           1166           6637
kismi, kesicili                    5000              0           1021              0            145           1166           6637
yavaslama, kesicisiz               4329            671            190              0            826           1016          19312
yavaslama, kesicili                5000              0            190            953             23            213           1646
durma, kesicisiz                   5000              0            190              0            976           1166           4144
durma, kesicili                    5000              0            190            953             23            213           1285

arizasiz gunun bedeli: 1166 cagrinin hepsinde kesici sorgulanir ve 20 kayitlik pencere tutulur; 0 yanlis acilma, 0 reddedilen gecerli olay; kismi arizada 0 acilma ve olay yanit 1021 -> 1021 (0 basarili olabilecek olay reddedildi)
arizali gunun kazanci (yavaslama): takip yuvasiz 671 -> 0, olay yuva-tur 19312 -> 1646 (%91.48 az), bozuk bagimliliga cagri 1016 -> 213
ayni kazanc durmada: takip yuvasiz 0 -> 0, olay yuva-tur 4144 -> 1285, cagri 1166 -> 213
AY3'un 10 dakikasina olcek: yavaslamada tasarruf edilen cagri 48180, kurtarilan takip istegi 40260

kural             kip         algilama turu algilamaya kadar yuva-tur  acilma  reddedilen gecerli olay
ardisik 5         saglikli                -                         -       0                        0
ardisik 5         kismi                   -                         -       0                        0
ardisik 5         yavaslama               4                       110      10                        -
ardisik 5         durma                   4                        15      10                        -
oran 0,50 / 20    saglikli                -                         -       0                        0
oran 0,50 / 20    kismi                   -                         -       0                        0
oran 0,50 / 20    yavaslama               9                       220      10                        -
oran 0,50 / 20    durma                   9                        30      10                        -
oran 0,10 / 20    saglikli                -                         -       4                      386
oran 0,10 / 20    kismi                  88                       117       9                      698
oran 0,10 / 20    yavaslama              67                        22      11                        -
oran 0,10 / 20    durma                  67                         3      11                        -
duyarlilik: kesik suresi 100 yerine 200 tur olsaydi yavaslamada yapilan cagri 213 -> 208; oran 0,10 kuralinda arizasiz gunde reddedilen gecerli olay 386 -> 741
```

Bu sayılar **ölçüm** sınıfındadır ve tohuma bağlıdır; aynı tohum aynı tabloyu verir.

İlk iki satır kalıbın arızasız gündeki bedelini veriyor ve bedel şaşırtıcı derecede küçüktür.
Sağlıklı günde kesicili ile kesicisiz koşum **birbirinin aynıdır**: 5000 takip yanıtı, 1135 olay
yanıtı, 0 yanlış açılma, 0 reddedilen geçerli olay. Bedel sayılabilir ama küçüktür — kesici 1166
çağrının hepsinde sorgulanır ve bağımlılık başına 20 kayıtlık bir pencere tutar. **Doğru
boyutlandırılmış bir eşik arızasız günde görünmez olur.**

Üçüncü ve dördüncü satır kazancı veriyor. Yavaşlama kipinde kesicisiz koşumda 5000 takip isteğinin
671'i yuva bulamıyor — 01. dersin bulaşma tablosunun tur düzeyindeki karşılığı budur. Kesici
konduğunda bu sayı **0** oluyor: takip sorgusu, kendisiyle hiç ilgisi olmayan bir bağımlılığın
yavaşlamasından artık etkilenmiyor. Olay bacağının tuttuğu yuva-tur 19.312'den 1646'ya iniyor, yani
yüzde 91,48 azalıyor, ve bozuk bağımlılığa yapılan çağrı 1016'dan 213'e düşüyor. AY3'ün 10
dakikalık yavaşlamasına ölçeklendiğinde bu, tasarruf edilen 48.180 çağrı ve kurtarılan 40.260 takip
isteği eder.

Beşinci ve altıncı satır kesicinin **neyi kurtarmadığını** gösteriyor. Durma kipinde kesicisiz
koşumda takip yuvasız isteği zaten 0'dır; hızlı hata yuvayı tutmadığı için bulaşma yoktur ve
kesicinin koruyacak bir şeyi kalmaz. Orada kazanç başka bir yerdedir: yapılan çağrı 1166'dan 213'e,
yuva-tur 4144'ten 1285'e iner. Duran bir bağımlılıkta kesici **bulaşmayı değil, boşa giden işi**
keser.

Bir satır da kalıbın kendi bedelini itiraf ediyor: kesicili yavaşlama koşumunda 953 olay
reddediliyor. Kesici olay akışını kurtarmıyor, onu **çevreliyor**. Reddedilen 953 durum olayı hâlâ
gerçek olaylardır ve bir yere gitmek zorundadır; onları nereye koyacağı bu kalıbın sorusu değildir.

## Eşik Arıza Kipine Göre Seçilir

İkinci tablo üç eşik kuralını dört kipte koşturuyor ve tek bir eşiğin dört kipi birden
karşılayamayacağını gösteriyor.

**Ardışık başarısızlık sayısı en ucuz kuraldır ama kısmi arızayı hiç görmez.** Ardışık 5 kuralı
yavaşlamayı ve durmayı 4. turda yakalıyor, sağlıklı günde bir kez bile yanlış açmıyor — ama kısmi
arızada da hiç açmıyor. Nedeni aritmetiktir: sekizde bir başarısızlık oranında beş çağrının arka
arkaya başarısız olması ender bir olaydır. Kısmi arızada bu doğru davranıştır; çağrıların yedi
bölü sekizi hâlâ başarılıdır ve kesmek kazançtan çok kayıp getirir.

**Algılamanın gecikmesi değil, bedeli kipe göre değişiyor.** Ardışık 5 kuralında hem durma hem
yavaşlama 4. turda algılanıyor; eşzamanlı çağrılar beş başarısızlığı aynı hızda biriktiriyor. Ama
algılamaya kadar tutulan yuva-tur durmada 15, yavaşlamada 110 — **7,3 kat.** Oran 0,50 kuralında
fark daha da açılıyor: 30'a karşı 220. Eşik sayıyla değil, o sayının kaç yuva-tura mal olduğuyla
seçilmelidir; yavaş bir bağımlılıkta yirmi çağrı beklemek yüz yirmi çağrı beklemeye denktir.

## Yanlış Açılmanın Bedeli

Üçüncü kural bunu tersinden gösteriyor. Oran 0,10 eşiği yavaşlamayı ve durmayı çok daha ucuza
yakalıyor — algılamaya kadar yalnız 22 ve 3 yuva-tur — ve kısmi arızayı da 88. turda görüyor. Bedeli
öteki iki sütundadır.

Sağlıklı günde bu kural 4 kez açılıyor ve **386 geçerli olayı reddediyor**; bağımlılıkta hiçbir
sorun yokken. Kısmi arızada 9 kez açılıyor ve 698 geçerli olayı reddediyor — oysa o olayların
başarılı olma olasılığı sekizde yediydi. **Yanlış açılma sağlıklı bir bağımlılığı kesmektir ve
bedeli reddedilen geçerli istektir.**

Duyarlılık satırı bu bedelin kesik süresine bağlı olduğunu söylüyor: kesik 100 turdan 200 tura
çıkarılsaydı yavaşlamada yapılan çağrı 213'ten 208'e inerdi — neredeyse hiç kazanç — ama sağlıklı
günde reddedilen geçerli olay 386'dan 741'e çıkardı. **Kesik süresini uzatmak arızalı günde az
kazandırır, arızasız günde çok kaybettirir**, çünkü kazanç arızanın süresine değil kesicinin bir
kez açılmasına bağlıdır, kayıp ise doğrudan kesik süresiyle çarpılır.

## Özet

- Devre kesici bir bağımlılığı devreden çıkarır; kapalı, açık ve yarı açık durumları Uygulama
  Mimarisi kursunda kuruldu ve burada tekrarlanmaz. Servisler arasında koruduğu şey çağıranın
  paylaşılan yuva havuzudur.
- Doğru boyutlandırılmış eşik arızasız günde görünmezdir: sağlıklı günde kesicili ve kesicisiz koşum
  aynı sayıları veriyor, 0 yanlış açılma. Bedel 1166 çağrının her birinde yapılan bir denetim ve
  bağımlılık başına 20 kayıtlık penceredir.
- Yavaşlamada kazanç büyüktür: yuva bulamayan takip isteği 671 → 0, olay bacağının yuva-turu 19.312
  → 1646 (%91,48 az), bozuk bağımlılığa çağrı 1016 → 213. AY3'ün 10 dakikasında 48.180 çağrı
  tasarrufu ve 40.260 kurtarılan takip isteği.
- Durmada bulaşma zaten yoktur (takip yuvasız 0 → 0); oradaki kazanç boşa giden iştir: çağrı 1166 →
  213, yuva-tur 4144 → 1285.
- Algılamanın bedeli kipe göre değişir, gecikmesi değil: ardışık 5 kuralı iki kipi de 4. turda
  yakalar ama algılamaya kadar tutulan yuva-tur durmada 15, yavaşlamada 110.
- Yanlış açılma sağlıklı bağımlılığı keser: oran 0,10 eşiği sağlıklı günde 386, kısmi arızada 698
  geçerli olayı reddeder; kesik süresi 200 tura çıkarılırsa sağlıklı gündeki kayıp 741'e çıkar,
  arızalı gündeki kazanç ise 213'ten 208'e ancak iner.

## Sonraki Adım

Kesici bir sınır çizdi ama sınırın yeri dikkatle okunmalı: koruma **algılamadan sonra** başlıyor.
Oran 0,50 kuralında yavaşlama 9. turda algılanıyor ve o dokuz tur boyunca bozuk bağımlılık
paylaşılan havuzdan 220 yuva-tur çekiyor. Eşiği düşürmek bu payı küçültür ama yanlış açılmayı
büyütür; ikisi birden küçültülemez. Dahası kesici her bağımlılığa ayrı ayrı konur, oysa havuz
tektir: kesicisi olmayan ya da eşiğinin altında kalan bir yavaşlama havuzu yine tüketir ve komşu
akışı yine düşürür. O hâlde bir soru daha vardır — bulaşmayı algılamaya hiç bağlamadan kesmek
mümkün müdür. Sonraki ders havuzun kendisini böler: her akışa kendi yuvaları verilir, bir akışın
tüketebileceği kaynak baştan sınırlanır ve bunun arızasız günde ne kadara mal olduğu sayılır.
