ახსენით async მოდელები: callback-ები, promise-ები, async/await და event loop.

Question

IT Interview Practice · Accepted Answer

**ეს არის თანდათან უკეთესი გზები non-blocking სამუშაოს გამოსახატავად ერთ thread-ზე, ყველა მართული ქვემოთ event loop-ით, რომელიც უშვებს მზა callback-ებს თითო-თითოდ.** ისინი მართავენ, *როდის* განახლდება კოდი და არა მრავალ thread-ს.

## Event loop

ერთ-thread-იანი loop ინახავს მზა callback-ების queue-ს. როცა async ოპერაცია (timer, I/O) სრულდება, მისი callback ჩაირიცხება queue-ში; loop იღებს მომდევნოს და უშვებს მას დასრულებამდე, შემდეგ იმეორებს. არაფერი წყვეტს მიმდინარე callback-ს, ამიტომ ხანგრძლივი CPU სამუშაო ბლოკავს ყველაფერს.

```text
[event loop] → run callback → I/O finishes → enqueue callback → run next → ...
```

## სამი სტილი

```js
// 1. Callbacks — ჩალაგება უშნო ხდება ("callback hell")
readFile('a', (e, a) => readFile('b', (e, b) => done(a, b)));

// 2. Promises — ჯაჭვური, ბრტყელი შეცდომების დამუშავება
readFile('a').then(a => readFile('b')).then(b => ...).catch(err => ...);

// 3. async/await — თანმიმდევრულად გამოიყურება, მაინც non-blocking
async function run() {
  const a = await readFile('a');   // უთმობს loop-ს ლოდინის დროს
  const b = await readFile('b');
  return done(a, b);
}
```

`await` აჩერებს ფუნქციას და აბრუნებს კონტროლს event loop-ს; როცა promise resolve-დება, შესრულება განახლდება იქ, სადაც შეჩერდა. ეს არის სინტაქსური შაქარი promise-ების თავზე — იგივე event loop ქვემოთ.

## რატომ არის ეს მნიშვნელოვანი

ეს მოდელი ამუშავებს Node.js-ს, browser-ებსა და Python asyncio-ს: მასიური I/O თანადროულობა ერთ thread-ზე lock-ის სირთულის გარეშე. ხაფანგი ის არის, რომ არასდროს არ უნდა დაბლოკოთ loop — synchronous CPU-ზე მძიმე ან blocking გამოძახება აჩერებს ყოველ მოლოდინში მყოფ დავალებას. იმის გაგება, რომ async ≠ parallel, არის ხშირი ინტერვიუს განმასხვავებელი.

Event loop

სამი სტილი

რატომ არის ეს მნიშვნელოვანი

დაკავშირებული კითხვები