შეადარეთ actor model და CSP (channel-ები). როგორ ეხმარება message passing?

Question

IT Interview Practice · Accepted Answer

**ორივე აცილებს გაზიარებულ ცვალებად მდგომარეობას იმით, რომ თანადროული entity-ები კომუნიცირებენ შეტყობინებებით და არა lock-ებით — actor-ები ფლობენ პირად მდგომარეობას და აგზავნიან მისამართიან შეტყობინებებს; CSP-ს აქვს ანონიმური process-ები, რომლებიც გადასცემენ მნიშვნელობებს channel-ების გავლით.** "Don't communicate by sharing memory; share memory by communicating."

## Actor model (Erlang, Akka)

თითო actor-ს აქვს პირადი mailbox და ამუშავებს შეტყობინებებს თითო-თითოდ. Actor-ები დასახელებული/მისამართიანია, აგზავნიან ასინქრონულად (fire-and-forget) და არასდროს იზიარებენ მდგომარეობას — ამიტომ actor-ის შიგნით lock-ები არ არის საჭირო. Supervision tree-ები რესტარტავენ ავარიაში ჩავარდნილ actor-ებს.

```text
Actor A ──send msg──▶ [mailbox] Actor B  (B ამუშავებს სერიულად, საკუთარი მდგომარეობა)
```

## CSP (Go, occam)

Process-ები ანონიმურია; ისინი კომუნიცირებენ **channel**-ების გავლით. Send/receive rendezvous (unbuffered channel-ები ბლოკავენ, სანამ ორივე მხარე მზად არ იქნება) უზრუნველყოფს სინქრონიზაციას. Channel და არა process არის დასახელებული entity.

```go
ch := make(chan int)
go func() { ch <- compute() }()   // goroutine აგზავნის channel-ში
result := <-ch                    // main იღებს; ბლოკავს, სანამ არ გაიგზავნება
```

## ძირითადი განსხვავებები

- **Addressing**: actor-ები მიმართავენ ერთმანეთს; CSP მიმართავს channel-ებს.
- **Coupling**: actor-ის send არის ასინქრონული და ბუფერიზებული (mailbox); კლასიკური CSP send არის სინქრონული rendezvous.
- **Topology**: channel-ები შეიძლება გადავიდეს და multiplex-დეს (Go-ს `select`); actor-ები ქმნიან supervision იერარქიას.

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

Message passing აქცევს გაზიარებულ-მეხსიერების race condition-ებს დალაგებულ შეტყობინებების დამუშავებად — თითო entity-ის მდგომარეობას ეხება ერთი thread, რაც აცილებს lock-ების უმეტესობას და მსჯელობას ლოკალურ ხდის. ეს არის მასშტაბირებადი, fault-tolerant სისტემების საფუძველი (Erlang telecom, Go სერვისები). actor-vs-CSP განსხვავების ცოდნა აჩვენებს, რომ შეგიძლიათ აირჩიოთ სწორი concurrency არქიტექტურა და არა უბრალოდ დაამატოთ thread-ები და lock-ები.

Actor model (Erlang, Akka)

CSP (Go, occam)

ძირითადი განსხვავებები

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

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