در گولنگ, گوروتین‌ها می‌توانند از طریق channelها مقادیر را به یکدیگر منتقل کنند. یک channel شبیه یک لوله است که یک goroutine می‌تواند چیزی را داخلش بیندازد و گوروتین دیگری آن را در طرف دیگر دریافت کند.

هر چنل دارای یک دیتا تایپ است که مشخص میکند چه نوع داده ای را می‌تواند انتقال دهد. برای تعریف یک چنل می توانیم از chan به همراه دیتا تایپی که باید انتقال پیدا کند استفاده کنیم:

package main

import "fmt"

func main() {
    messages := make(chan string)

    go func() {
        messages <- "ping"
    }()

    msg := <- messages
    fmt.Println("received message:", msg)
}

برای ارسال و دریافت اطلاعات از چنل از عملگر <- استفاده می‌کنیم. اگر جهت آن به سمت چنل باشد یک پیام به چنل ارسال می‌شود:

messages := make(chan string)

messages <- "hello world"

و اگر خلاف جهت چنل باشند یک پیام از چنل دریافت می‌شود:

msg := <- messages

وقتی یک گوروتین می‌خواهد مقداری را به یک channel ارسال کند یا مقداری از آن دریافت کند، اجرای آن در همان نقطه متوقف یا بلاک می‌شود تا عملیات تکمیل شود. در هنگام ارسال (messages <- “ping”)، گوروتین فرستنده منتظر می‌ماند تا یک گوروتین دیگر آن مقدار را از چنل دریافت کند.

در هنگام دریافت (<-messages)، گوروتین گیرنده منتظر می‌ماند تا یک مقدار برای خواندن در چنل موجود شود. به عبارت دیگر، چنل نقطه‌ای است که گوروتین‌ها در آن به هم وصل می‌شوند و اجرای آن‌ها تا زمان تکمیل عملیات متوقف می‌شود.

این همان مفهوم بلوک شدن (blocking) در زمان ارسال و دریافت است. ارسال و دریافت در یک چنل در واقع یک جفت عملیات همزمان هستند. ارسال بدون دریافت کامل نمی‌شود (و همچنین بلعکس) و فقط زمانی که عمل دریافت انجام شد، هر دو گوروتین می‌توانند به اجرای خود ادامه دهند.

اعلام خاتمه‌ی ارتباط

 هنگامی که گوروتین‌ها از طریق چنل (channel) با هم ارتباط دارند، یکی از چالش‌های مهم این است که چطور پایان ارتباط را اعلام کنیم. سه روش رایج وجود دارد که هرکدام مزایا و معایب خاص خودشان را دارند.

1. ارسال مقدار صفر (Zero Value)

در گولنگ هر نوع از داده دارای یک مقدار صفر (zero value) است. این مقدار وقتی متغیری تعریف می‌کنیم به آن نسبت داده می‌شود به عنوان مثال:

• مقدار صفر برای int
• رشته متنی خالی برای string
• مقدار false برای نوع bool

یک روش برای اعلام پایان ارتباط ارسال مقدار صفر یا zero value به چنل است.

package main

import "log"

func main() {
    ch := make(chan int)

    go func() {
        ch <- 2
        ch <- 1
        ch <- 0 // اعلام پایان ارتباط
	}

    for {
        val := <- ch
        if val == 0 {
            log.Println("the termination signal recieved")
        }

        log.Println("value is:", val)
    }
}

این روش دارای مزایا و معایبی نسبت به باقی روش هایی است که در ادامه بررسی خواهیم کرد.

• مزایا

  • ساده و سریع برای پیاده‌سازی

  • نیاز به ساختار اضافه ندارد

• معایب

  • ابهام: اگر مقدار صفر جزو داده‌های واقعی باشد، تشخیص پایان سخت می‌شود.

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

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

2. ارسال مقدار Sentinel (مقدار خاص برای پایان)

در این روش یک مقدار خاص مثلا -1 یا END را برای اعلام قطع ارتباط مورد استفاده قرار می‌دهیم:

package main

import "log"

const ENDSignal = -1

func main() {
    ch := make(chan int)

    go func() {
        ch <- 2
        ch <- 1
        ch <- ENDSignal // اعلام پایان ارتباط
	}

    for {
        val := <- ch
        if val == EndSignal {
            log.Println("the termination signal recieved")
        }

        log.Println("value is:", val)
    }
}

• مزایا

  • واضح‌تر از zero value 
  • کنترل بیشتری روی پروتکل ارتباطی می‌دهد

• معایب

  • هنوز هم اگر مقدار sentinel در داده واقعی وجود داشته باشد، مشکل ایجاد می‌شود.
  • نیاز به تعریف یک قرارداد (پروتکل) بین sender و receiver دارد.

این روش نیز در حالتی که هدف تنها پایان ارتباط است مورد استفاده قرار نمی‌گیرد. روش استاندارد برای اعلام پایان ارتباط, بستن چنل است که در ادامه مورد بررسی قرار می‌دهیم.

3. بستن چنل (Close Channel)

در Go بهترین روش برای اعلام پایان ارتباط این است که چنل را ببندیم.

package main

import "log"

func main() {
    ch := make(chan int)

    go func() {
        ch <- 2
        ch <- 1
        close(ch) // اعلام پایان ارتباط
	}

    for {
        val, ok := <- ch
        if !ok {
            log.Println("the termination signal recieved")
        }

        log.Println("value is:", val)
    }
}

بعد از بسته شدن چنل در Go، اگر چنل خالی باشد، هر بار خواندن از آن مقدار پیش‌فرض (zero value) را برمی‌گرداند؛ برای تشخیص اینکه این مقدار داده واقعی است یا نتیجه بسته شدن چنل، می‌توان از مقدار دوم (ok) استفاده کرد که از نوع بولی است و وقتی false باشد نشان می‌دهد چنل بسته شده و مقدار دریافت‌شده واقعی نیست. 

در ادامه رفتار و جزییات چنل ها را در هنگامی که بسته (close) شوند بررسی خواهیم کرد.

• مزایا

  • روش رسمی و توصیه‌شده در Go
  • بدون ابهام
  • سازگار با range روی channel
  • خواناتر و قابل نگهداری‌تر

• معایب

  • فقط sender باید چنل را ببندد (وگرنه panic می‌دهد).
  • اگر چند sender داشته باشیم، مدیریت سخت‌تر می‌شود.

خواندن اطلاعات از روی چنل

خواندن از channel یعنی دریافت داده‌ای که توسط یک goroutine دیگر ارسال شده است و این عملیات به‌صورت پیش‌فرض بلاک‌کننده (blocking) است؛ یعنی اگر داده‌ای در چنل موجود نباشد، goroutine منتظر می‌ماند تا مقداری ارسال شود.

package main

import "fmt"

func main() {
    ch := make(chan string)

    go func() {
        ch<-"hello world"
    }()

    fmt.Println(<-ch)
}

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

package main

import "fmt"

func main() {
    ch := make(chan string)

    go func() {
        ch<-"Hi"
        ch<-"This"
        ch<-"Is"
        ch<-"Working"
        close(ch)
    }()

    for{
        msg,ok := <-ch
        if !ok {
            break
    	}

        fmt.Println(msg)    	
    }
}

استفاده از range روی چنل، روشی رایج و خوانا برای دریافت پیوسته داده‌ها تا زمان بسته شدن آن است.

package main

import "fmt"

func main() {
    ch := make(chan string)

    go func() {
        ch<-"Hi"
        ch<-"This"
        ch<-"Is"
        ch<-"Working"
        close(ch)
    }()

    for msg := range ch{
        fmt.Println(msg)    	
    }
}

چنل‌های یک طرفه (Uni-directional)

چنل‌ها در Go به‌صورت پیش‌فرض دوطرفه (‌bi-directional) هستند بدین معنی که امکان ارسال و دریافت داده‌ها را فراهم می‌کنند. می‌توان چنل‌ها را به‌گونه‌ای تعریف کرد که فقط برای ارسال یا فقط برای دریافت داده‌ها مورد استفاده قرار گیرند.

چنل فقط فرستنده و فقط گیرنده به شکل های زیر هستند:

// چنل یک‌طرفه: فقط فرستنده
chan<- string

// چنل یک‌طرفه: فقط گیرنده
<-chan string

با استفاده از چنل های یک‌طرفه, مثالی که قبل‌تر داشتیم رو می‌توانیم به صورت زیر بازنویسی کنیم:

package main

import "fmt"

// فقط ارسال
func send(ch chan<- string) {
        ch<-"Hi"
        ch<-"This"
        ch<-"Is"
        ch<-"Working"
        close(ch)
}

// فقط دریافت
func recieve(ch <-chan string) {
    for msg := range ch{
        fmt.Println(msg)    	
    }
}

func main() {
    ch := make(chan string)

    go send(ch)
    recieve(ch)
}

چنل های یک طرفه (فقط فرستنده و یا فقط گیرنده) مزایا و معایبی دارند.

• مزایای چنل یک‌طرفه

  • کامپایلر در Go جلوی استفاده نادرست را می‌گیرد؛ به‌عنوان مثال، اگر چنلی فقط برای دریافت تعریف شده باشد، امکان ارسال داده به آن وجود نخواهد داشت.

  • نوع چنل به‌وضوح نقش هر goroutine را مشخص می‌کند (فقط فرستنده یا فقط گیرنده).

  • بسیاری از خطاهای همزمانی، مانند ارسال ناخواسته یا استفاده نادرست از چنل، در همان زمان کامپایل شناسایی می‌شوند.

  • وقتی تابعی تنها یک <-chan به‌عنوان ورودی می‌گیرد، تضمین می‌شود که صرفاً مصرف‌کننده است و در تولید یا تغییر جریان داده دخالتی ندارد.

• معایب چنل یک‌طرفه

  • چنل‌های یک‌طرفه انعطاف‌پذیری کمتری دارند و نمی‌توان از آن‌ها برای هر دو عمل ارسال و دریافت استفاده کرد، حتی اگر بعداً نیاز تغییر کند.

  • در پروژه‌های کوچک، ممکن است باعث پیچیده‌تر شدن امضای توابع و کاهش خوانایی اولیه شود.

  • در برخی موارد نیاز به تبدیل بین چنل‌های دوطرفه و یک‌طرفه وجود دارد که می‌تواند کد را کمی پیچیده‌تر کند.

  • در سناریوهایی با چندین فرستنده یا گیرنده، محدود کردن جهت چنل‌ها ممکن است طراحی را دشوارتر کند.

چنل‌های بافر شده (Buffered Channels)

چنل‌های بافر (Buffered Channels) در Go نوعی از چنل‌ها هستند که می‌توانند تعدادی مقدار را بدون نیاز به دریافت فوری نگه دارند؛ برخلاف چنل‌های معمولی (unbuffered) که ارسال و دریافت باید همزمان انجام شود. چنل‌های بافر مشابه یک صف (queue) با ظرفیت مشخص عمل می‌کنند.

// تعریف متغیر از نوع چنل عددی
var x chan int

// تخصیص حافظه به صورت چنل عادی
x = make(chan int)

// تخصیص حافظه به صورت چنل بافر
x = make(chan int, 3) // چنل با ظرفیت 3

همانطور که در مثال بالا میبینیم هیچ تفاوتی در تعریف چنل ایجاد نمی‌شود و تنها در هنگام تخصیص حافظه می‌توان مشخص کرد که یک چنل بافر شده باشد یا نه.

رفتار چنل بافر شده به صورت زیر است:

• تا وقتی بافر پر نشده باشد, ارسال داده به چنل بلاک نمی‌شود.
• اگر بافر پر شود ارسال داده به چنل بلاک می‌شود تا هنگامی که دریافت از چنل انجام شود. (مشابه چنل غیر بافر شده)
• اگر بافر خالی باشد دریافت داده بلاک می‌شود تا هنگامی که ارسال به چنل انجام شود. (مشابه چنل غیر بافر شده)

چطور متوجه بشیم از چنل‌های بافر شده باید استفاده کنیم؟

• معمولا زمانی از چنل‌های بافر شده استفاده میشود که نمی‌خواهیم عملیات ارسال و دریافت دقیقاً همزمان انجام شوند. 
• اگر دلیل مشخصی برای استفاده از چنل بافر وجود ندارد نباید از آن استفاده کرد. 
• اگر نیاز به همگام‌سازی دقیق است, نباید از چنل‌های بافر شده استفاده کرد.

معمولا کد را می‌توان اول بدون استفاده از چنل‌های بافر شده نوشت و سپس در صورت نیاز چنل را به بافر شده تبدیل کرد.

بستن چنل (close)

به زودی…

چنل‌های nil

به زودی…