تسلط بر Go Concurrency: الگوهای ضروری برای سیستم های با کارایی بالا

Summarize this content to 400 words in Persian Lang
همزمانی در قلب طراحی Go است و آن را به انتخابی عالی برای ساخت سیستم‌های با کارایی بالا تبدیل می‌کند. به عنوان یک توسعه دهنده که به طور گسترده با Go کار کرده است، دریافته ام که تسلط بر الگوهای همزمانی برای ایجاد برنامه های کاربردی کارآمد و مقیاس پذیر بسیار مهم است.

بیایید با اصول اولیه شروع کنیم: گوروتین ها و کانال ها. گوروتین ها رشته های سبک وزنی هستند که توسط زمان اجرا Go مدیریت می شوند و به ما امکان می دهند توابع را همزمان اجرا کنیم. از سوی دیگر، کانال ها راهی را برای گوروتین ها برای برقراری ارتباط و همگام سازی اجرای خود فراهم می کنند.

در اینجا یک مثال ساده از استفاده از گوروتین ها و کانال ها آورده شده است:

func main() {
ch := make(chan int)
go func() {
ch <- 42
}()
result := <-ch
fmt.Println(result)
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

در این کد، یک کانال ایجاد می کنیم، یک گوروتین را شروع می کنیم که یک مقدار را به کانال ارسال می کند و سپس آن مقدار را در تابع اصلی دریافت می کنیم. این اصل اساسی استفاده از کانال ها برای ارتباط بین گوروتین ها را نشان می دهد.

یکی از قدرتمندترین ویژگی های جعبه ابزار همزمانی Go دستور select است. این به یک گوروتین اجازه می دهد تا در چند عملیات کانال به طور همزمان منتظر بماند. در اینجا یک مثال است:

func main() {
ch1 := make(chan int)
ch2 := make(chan int)
go func() {
ch1 <- 42
}()
go func() {
ch2 <- 24
}()
select {
case v1 := <-ch1:
fmt.Println(“Received from ch1:”, v1)
case v2 := <-ch2:
fmt.Println(“Received from ch2:”, v2)
}
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

این دستور select منتظر یک مقدار از ch1 یا ch2 می‌شود، هر کدام که زودتر بیاید. این یک ابزار قدرتمند برای مدیریت چندین عملیات همزمان است.

اکنون، بیایید به الگوهای همزمانی پیشرفته تری بپردازیم. یکی از الگوهای رایج، گروه کارگر است که برای پردازش تعداد زیادی از وظایف به طور همزمان مفید است. در اینجا یک پیاده سازی است:

func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
fmt.Printf(“Worker %d processing job %d\n”, id, j)
time.Sleep(time.Second) // Simulate work
results <- j * 2
}
}

func main() {
jobs := make(chan int, 100)
results := make(chan int, 100)

for w := 1; w <= 3; w++ {
go worker(w, jobs, results)
}

for j := 1; j <= 9; j++ {
jobs <- j
}
close(jobs)

for a := 1; a <= 9; a++ {
<-results
}
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

در این مثال، ما مجموعه‌ای از سه گوروتین کارگری ایجاد می‌کنیم که کارهای یک کانال را پردازش می‌کند. این الگو برای توزیع کار در چندین پردازنده و مدیریت کارآمد وظایف همزمان بسیار عالی است.

الگوی قدرتمند دیگر خط لوله است که شامل یک سری مراحل است که توسط کانال هایی به هم متصل می شوند، که در آن هر مرحله گروهی از گوروتین ها هستند که عملکرد مشابهی را اجرا می کنند. در اینجا یک مثال است:

func gen(nums …int) <-chan int {
out := make(chan int)
go func() {
for _, n := range nums {
out <- n
}
close(out)
}()
return out
}

func sq(in <-chan int) <-chan int {
out := make(chan int)
go func() {
for n := range in {
out <- n * n
}
close(out)
}()
return out
}

func main() {
c := gen(2, 3)
out := sq(c)

fmt.Println(<-out)
fmt.Println(<-out)
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

این خط لوله اعداد را تولید می کند، آنها را مربع می کند و سپس نتایج را چاپ می کند. هر مرحله از خط لوله در گوروتین خاص خود اجرا می شود و امکان پردازش همزمان را فراهم می کند.

الگوی fan-out/fan-in زمانی مفید است که چندین گوروتین از یک کانال می خوانیم و عملیات زمان بری را انجام می دهیم. در اینجا نحوه اجرای آن آمده است:

func fanOut(in <-chan int, n int) []<-chan int {
outs := make([]<-chan int, n)
for i := 0; i < n; i++ {
outs[i] = make(chan int)
go func(ch chan<- int) {
for v := range in {
ch <- v * v
}
close(ch)
}(outs[i])
}
return outs
}

func fanIn(chans …<-chan int) <-chan int {
out := make(chan int)
var wg sync.WaitGroup
wg.Add(len(chans))
for _, ch := range chans {
go func(c <-chan int) {
for v := range c {
out <- v
}
wg.Done()
}(ch)
}
go func() {
wg.Wait()
close(out)
}()
return out
}

func main() {
in := gen(1, 2, 3, 4, 5)
chans := fanOut(in, 3)
out := fanIn(chans…)

for v := range out {
fmt.Println(v)
}
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

این الگو به ما اجازه می دهد تا کار را در چندین گوروتین توزیع کنیم و سپس نتایج را در یک کانال واحد جمع آوری کنیم.

هنگام پیاده سازی این الگوها در سیستم های با کارایی بالا، در نظر گرفتن چندین فاکتور بسیار مهم است. اول، باید به تعداد گوروتین هایی که می سازیم توجه کنیم. در حالی که گوروتین ها سبک وزن هستند، ایجاد بیش از حد می تواند منجر به افزایش استفاده از حافظه و زمان بندی سربار شود.

همچنین باید مراقب بن بست های احتمالی باشیم. همیشه اطمینان حاصل کنید که برای هر عملیات ارسال در یک کانال، عملیات دریافت مربوطه وجود دارد. استفاده از کانال‌های بافر می‌تواند در برخی از سناریوها به جلوگیری از مسدود شدن غیرضروری گوروتین‌ها کمک کند.

رسیدگی به خطا در برنامه های همزمان نیازمند توجه ویژه است. یک روش استفاده از یک کانال خطای اختصاصی است:

func worker(jobs <-chan int, results chan<- int, errs chan<- error) {
for j := range jobs {
if j%2 == 0 {
results <- j * 2
} else {
errs <- fmt.Errorf(“odd number: %d”, j)
}
}
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

این به ما امکان می دهد تا بدون مسدود کردن گوروتین های کارگر، خطاها را مدیریت کنیم.

ملاحظات مهم دیگر استفاده از mutexes هنگام برخورد با منابع مشترک است. در حالی که کانال ها راه ارجح برای ارتباط بین گوروتین ها هستند، mutexe ها گاهی اوقات ضروری هستند:

type SafeCounter struct {
mu sync.Mutex
v map[string]int
}

func (c *SafeCounter) Inc(key string) {
c.mu.Lock()
c.v[key]++
c.mu.Unlock()
}

func (c *SafeCounter) Value(key string) int {
c.mu.Lock()
defer c.mu.Unlock()
return c.v[key] }

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

این SafeCounter می تواند با خیال راحت توسط چندین گوروتین به طور همزمان استفاده شود.

هنگام ساخت سیستم های با کارایی بالا، اغلب لازم است تعداد عملیات همزمان محدود شود. برای این کار می توانیم از الگوی سمافور استفاده کنیم:

func main() {
const maxConcurrent = 3
sem := make(chan struct{}, maxConcurrent)

for i := 0; i < 1000; i++ {
sem <- struct{}{}
go func(i int) {
defer func() { <-sem }()
// Do some work
fmt.Println(“Processing”, i)
time.Sleep(time.Second)
}(i)
}
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

این تضمین می کند که در هر زمان معینی بیش از عملیات maxConcurrent اجرا نمی شود.

الگوی دیگری که در سیستم های با کارایی بالا مفید است، قطع کننده مدار است. این می تواند به جلوگیری از خرابی های آبشاری در سیستم های توزیع شده کمک کند:

type CircuitBreaker struct {
mu sync.Mutex
failureCount int
maxFailures int
reset time.Duration
lastFailure time.Time
}

func (cb *CircuitBreaker) Execute(work func() error) error {
cb.mu.Lock()
if cb.failureCount >= cb.maxFailures && time.Since(cb.lastFailure) < cb.reset {
cb.mu.Unlock()
return fmt.Errorf(“circuit breaker is open”)
}
cb.mu.Unlock()

err := work()
if err != nil {
cb.mu.Lock()
cb.failureCount++
cb.lastFailure = time.Now()
cb.mu.Unlock()
return err
}

cb.mu.Lock()
cb.failureCount = 0
cb.mu.Unlock()
return nil
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

این CircuitBreaker می تواند برای بسته بندی عملیات های بالقوه ناموفق و جلوگیری از تلاش های مکرر زمانی که یک سیستم تحت فشار است استفاده شود.

هنگام برخورد با عملیات طولانی مدت، مهم است که آنها را لغو کنید. بسته متنی Go برای این کار عالی است:

func longRunningOperation(ctx context.Context) error {
for {
select {
case <-ctx.Done():
return ctx.Err()
default:
// Do some work
}
}
}

func main() {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

err := longRunningOperation(ctx)
if err != nil {
fmt.Println(“Operation failed:”, err)
}
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

این تضمین می‌کند که اگر خیلی طول بکشد یا اگر تصمیم به لغو خارجی داشته باشیم، عملیات ما متوقف خواهد شد.

در سیستم‌های با کارایی بالا، اغلب لازم است که جریان‌های داده را همزمان پردازش کنید. در اینجا یک الگو برای این وجود دارد:

func processStream(stream <-chan int) <-chan int {
out := make(chan int)
go func() {
defer close(out)
for v := range stream {
out <- process(v)
}
}()
return out
}

func process(v int) int {
// Some CPU-intensive operation
return v * v
}

func main() {
stream := make(chan int)
go func() {
for i := 0; i < 1000; i++ {
stream <- i
}
close(stream)
}()

results := processStream(stream)
for r := range results {
fmt.Println(r)
}
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

این الگو به ما اجازه می دهد تا جریانی از داده ها را به طور همزمان پردازش کنیم و به طور بالقوه از چندین هسته CPU استفاده کنیم.

هنگام ساختن سیستم‌های با کارایی بالا در Go، تعیین مشخصات کد خود برای شناسایی تنگناها بسیار مهم است. Go ابزارهای نمایه سازی داخلی عالی را ارائه می دهد:

import _ “net/http/pprof”

func main() {
go func() {
log.Println(http.ListenAndServe(“localhost:6060”, nil))
}()

// Your main program logic here
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

این پروفایل pprof را فعال می کند که می توانید در http://localhost:6060/debug/pprof/ به آن دسترسی داشته باشید.

در نتیجه، الگوهای اولیه و همزمانی Go ابزار قدرتمندی برای ساختن سیستم‌های با کارایی بالا ارائه می‌کنند. با استفاده از گوروتین‌ها، کانال‌ها و الگوهای پیشرفته مانند استخرهای کارگر، خطوط لوله، و فن خروجی/فن ورودی، می‌توانیم برنامه‌های کارآمد و مقیاس‌پذیر ایجاد کنیم. با این حال، مهم است که از این ابزارها عاقلانه استفاده کنید و همیشه عواملی مانند استفاده از منابع، مدیریت خطا و شرایط بالقوه مسابقه را در نظر بگیرید. با طراحی دقیق و آزمایش کامل، می‌توانیم از قدرت کامل مدل همزمانی Go برای ساخت سیستم‌های قوی و با کارایی بالا استفاده کنیم.

مخلوقات ما

حتماً خلاقیت های ما را بررسی کنید:

مرکز سرمایه گذار | زندگی هوشمند | دوره ها و پژواک ها | اسرار گیج کننده | هندوتوا | Elite Dev | مدارس JS

ما در حالت متوسط ​​هستیم

بینش کوآلای فنی | دوران و پژواک جهان | سرمایه گذار مرکزی متوسط | گیج کننده اسرار رسانه | رسانه علم و عصر | هندوتوای مدرن

func main() {
    ch := make(chan int)
    go func() {
        ch <- 42
    }()
    result := <-ch
    fmt.Println(result)
}

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    go func() {
        ch1 <- 42
    }()
    go func() {
        ch2 <- 24
    }()
    select {
    case v1 := <-ch1:
        fmt.Println("Received from ch1:", v1)
    case v2 := <-ch2:
        fmt.Println("Received from ch2:", v2)
    }
}

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, j)
        time.Sleep(time.Second) // Simulate work
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 9; a++ {
        <-results
    }
}

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func sq(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func main() {
    c := gen(2, 3)
    out := sq(c)

    fmt.Println(<-out)
    fmt.Println(<-out)
}

func fanOut(in <-chan int, n int) []<-chan int {
    outs := make([]<-chan int, n)
    for i := 0; i < n; i++ {
        outs[i] = make(chan int)
        go func(ch chan<- int) {
            for v := range in {
                ch <- v * v
            }
            close(ch)
        }(outs[i])
    }
    return outs
}

func fanIn(chans ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    wg.Add(len(chans))
    for _, ch := range chans {
        go func(c <-chan int) {
            for v := range c {
                out <- v
            }
            wg.Done()
        }(ch)
    }
    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

func main() {
    in := gen(1, 2, 3, 4, 5)
    chans := fanOut(in, 3)
    out := fanIn(chans...)

    for v := range out {
        fmt.Println(v)
    }
}

func worker(jobs <-chan int, results chan<- int, errs chan<- error) {
    for j := range jobs {
        if j%2 == 0 {
            results <- j * 2
        } else {
            errs <- fmt.Errorf("odd number: %d", j)
        }
    }
}

type SafeCounter struct {
    mu sync.Mutex
    v  map[string]int
}

func (c *SafeCounter) Inc(key string) {
    c.mu.Lock()
    c.v[key]++
    c.mu.Unlock()
}

func (c *SafeCounter) Value(key string) int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.v[key]
}

func main() {
    const maxConcurrent = 3
    sem := make(chan struct{}, maxConcurrent)

    for i := 0; i < 1000; i++ {
        sem <- struct{}{}
        go func(i int) {
            defer func() { <-sem }()
            // Do some work
            fmt.Println("Processing", i)
            time.Sleep(time.Second)
        }(i)
    }
}

type CircuitBreaker struct {
    mu           sync.Mutex
    failureCount int
    maxFailures  int
    reset        time.Duration
    lastFailure  time.Time
}

func (cb *CircuitBreaker) Execute(work func() error) error {
    cb.mu.Lock()
    if cb.failureCount >= cb.maxFailures && time.Since(cb.lastFailure) < cb.reset {
        cb.mu.Unlock()
        return fmt.Errorf("circuit breaker is open")
    }
    cb.mu.Unlock()

    err := work()
    if err != nil {
        cb.mu.Lock()
        cb.failureCount++
        cb.lastFailure = time.Now()
        cb.mu.Unlock()
        return err
    }

    cb.mu.Lock()
    cb.failureCount = 0
    cb.mu.Unlock()
    return nil
}

func longRunningOperation(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
            // Do some work
        }
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    err := longRunningOperation(ctx)
    if err != nil {
        fmt.Println("Operation failed:", err)
    }
}

func processStream(stream <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for v := range stream {
            out <- process(v)
        }
    }()
    return out
}

func process(v int) int {
    // Some CPU-intensive operation
    return v * v
}

func main() {
    stream := make(chan int)
    go func() {
        for i := 0; i < 1000; i++ {
            stream <- i
        }
        close(stream)
    }()

    results := processStream(stream)
    for r := range results {
        fmt.Println(r)
    }
}

import _ "net/http/pprof"

func main() {
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()

    // Your main program logic here
}