Vivasoft-logo

[ā§Ē.⧍] āĻšā§āϝāĻžāύ⧇āϞ (Channels)

āĻāχ āĻĒāĻ°ā§āϝāĻžā§Ÿā§‡ āφāĻŽāϰāĻž Go āĻšā§āϝāĻžāύ⧇āϞ āύāĻŋā§Ÿā§‡ āĻ•āĻĨāĻž āĻŦāϞāĻŦā§‹āĨ¤ āĻšā§āϝāĻžāύ⧇āϞ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āϜāĻžāύāϤ⧇ āĻšāϞ⧇ āφāϗ⧇ āφāĻŽāĻžāĻĻ⧇āϰ āϜāĻžāύāϤ⧇ āĻšāĻŦ⧇ āĻšā§āϝāĻžāύ⧇āϞ āϕ⧀, āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āϕ⧇āύāχ āĻŦāĻž āφāĻŽāϰāĻž āĻšā§āϝāĻžāύ⧇āϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻŦā§‹āĨ¤ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āωāĻĻāĻžāĻšāϰāϪ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻŦāĻŋāώ⧟āϗ⧁āϞ⧋ āĻĻ⧇āĻ–āĻž āϝāĻžāĻ•āĨ¤

[ā§Ē.⧍.ā§§] āĻšā§āϝāĻžāύ⧇āϞ āϕ⧀ ?

Go āϤ⧇ āĻšā§āϝāĻžāύ⧇āϞ āĻšāϞ āĻĒāĻžāχāĻĒ āϞāĻžāχāύ⧇āϰ āĻŽāϤ⧋ āϝāĻžāϕ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻāĻ• āĻŦāĻž āĻāĻ•āĻžāϧāĻŋāĻ• āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āύāĻŋāĻœā§‡āĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āϝ⧋āĻ—āĻžāϝ⧋āĻ— āĻ•āϰ⧇āĨ¤ āĻŦāĻžāĻ¸ā§āϤāĻŦ⧇ āϝāĻĻāĻŋ āφāĻŽāϰāĻž āĻĒāĻžāχāĻĒ āϞāĻžāχāύ⧇āϰ āĻĻāĻŋāϕ⧇ āϤāĻžāĻ•āĻžāχ āϤāĻžāĻšāϞ⧇ āĻĻ⧇āĻ–āϤ⧇ āĻĒāĻžāĻŦā§‹ āĻĒāĻžāχāĻĒ āϞāĻžāχāύ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻĒāĻžāύāĻŋ āĻāĻ• āĻĒā§āϰāĻžāĻ¨ā§āϤ āĻĨ⧇āϕ⧇ āĻ…āĻ¨ā§āϝ āĻĒā§āϰāĻžāĻ¨ā§āϤ⧇ āĻĒā§āϰāĻŦāĻžāĻšāĻŋāϤ āĻšāĻšā§āϛ⧇, āĻāĻ•āχāĻ­āĻžāĻŦ⧇ āĻšā§āϝāĻžāύ⧇āϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻāĻ• āĻĒā§āϰāĻžāĻ¨ā§āϤ āĻĨ⧇āϕ⧇ āĻĄāĻžāϟāĻž āĻĒāĻžāĻ āĻžāύ⧋ āĻšā§Ÿ āĻāĻŦāĻ‚ āĻ…āĻ¨ā§āϝ āĻĒā§āϰāĻžāĻ¨ā§āϤ āĻĨ⧇āϕ⧇ āĻĄāĻžāϟāĻž āĻ—ā§āϰāĻšāĻŖ āĻ•āϰāĻž āĻšā§ŸāĨ¤Â  Go āϤ⧇ āĻĻ⧁āχ āϧāϰāύ⧇āϰ āĻšā§āϝāĻžāύ⧇āϞ āĻ°ā§Ÿā§‡āϛ⧇, buffered āĻšā§āϝāĻžāύ⧇āϞ āĻāĻŦāĻ‚ unbuffered āĻšā§āϝāĻžāύ⧇āϞāĨ¤ āĻĒāϰāĻŦāĻ°ā§āϤ⧀āϤ⧇ āφāĻŽāϰāĻž buffered āĻāĻŦāĻ‚ unbuffered āĻšā§āϝāĻžāύ⧇āϞ āύāĻŋā§Ÿā§‡ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻŦā§‹āĨ¤

[ā§Ē.⧍.⧍] āϕ⧇āύ āĻšā§āϝāĻžāύ⧇āϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻŦā§‹ ?

  1. āĻāĻ•āĻžāϧāĻŋāĻ• āĻ—ā§‹-āϰ⧁āϟāĻŋāύ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āϝ⧋āĻ—āĻžāϝ⧋āĻ— āϏāĻšāϜ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻ“  āĻĄāĻžāϟāĻž āĻŸā§āϰāĻžāĻ¨ā§āϏāĻĢāĻžāϰ⧇āϰ āϜāĻ¨ā§āϝ āĻšā§āϝāĻžāύ⧇āϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§ŸāĨ¤
  2. Go āϤ⧇ āĻšā§āϝāĻžāύ⧇āϞ⧇āϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ•ā§āϰ⧋āύāĻžāϏ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚āϕ⧇ āϏāĻšāϜ āĻ•āϰ⧇ āϤ⧋āϞ⧇āĨ¤
  3. Go āϤ⧇ āĻšā§āϝāĻžāύ⧇āϞ⧇āϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāĻ•āĻžāϧāĻŋāĻ• āĻĢāĻžāĻ‚āĻļāύ āĻŦāĻž āĻŽā§‡āĻĨāĻĄāϕ⧇ āĻāĻ•āχāϏāĻžāĻĨ⧇ āϰāĻžāύ āĻ•āϰāϤ⧇ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰ⧇āĨ¤

[ā§Ē.⧍.ā§Š]  āĻšā§āϝāĻžāύ⧇āϞ āĻĄāĻŋāĻ•ā§āĻ˛ā§‡ā§ŸāĻžāϰ

āĻĒā§āϰāĻ¤ā§āϝ⧇āĻ•āϟāĻŋ āĻšā§āϝāĻžāύ⧇āϞ āĻāϰ āϏāĻžāĻĨ⧇ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϟāĻžāχāĻĒ āĻāϏ⧋āϏāĻŋā§Ÿā§‡āĻŸā§‡āĻĄ āĻĨāĻžāϕ⧇āĨ¤ āĻāĻ•āϟāĻŋ āĻšā§āϝāĻžāύ⧇āϞ⧇ āĻļ⧁āϧ⧁ āĻāĻ•āχ āϟāĻžāχāĻĒ⧇āϰ āĻĄāĻžāϟāĻž āĻŸā§āϰāĻžāĻ¨ā§āϏāĻĒā§‹āĻ°ā§āϟ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āĻ…āĻ¨ā§āϝ āϟāĻžāχāĻĒ⧇āϰ āĻĄāĻžāϟāĻžāϕ⧇ āĻāϞāĻžāĻ“ āĻ•āϰ⧇ āύāĻžāĨ¤ āĻšā§āϝāĻžāύ⧇āϞ āĻ āĻ­ā§āϝāĻžāϞ⧁ āϰāĻŋāϏāĻŋāĻ­ āĻāĻŦāĻ‚ āϏ⧇āĻ¨ā§āĻĄā§‡āϰ āϜāĻ¨ā§āϝ <- āĻ…āĻĒāĻžāϰ⧇āϟāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§ŸāĨ¤

āϏāĻŋāύāĻŸā§āϝāĻžāĻ•ā§āϏ :

				
					myChannel := make(chan datatype)
				
			
gochan

āϝāĻĻāĻŋ āĻšā§āϝāĻžāύ⧇āϞ⧇ āϕ⧋āύ āĻŽāĻžāύ āύāĻž āĻĨāĻžāϕ⧇ āϤāĻžāĻšāϞ⧇ āϏ⧇āχ āĻšā§āϝāĻžāύ⧇āϞāϕ⧇ nil āĻšā§āϝāĻžāύ⧇āϞ āĻŦāϞ⧇āĨ¤ nil āĻšā§āϝāĻžāύ⧇āϞ āϕ⧋āύ āĻ•āĻžāĻœā§‡ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ āύāĻžāĨ¤ āϤāĻžāχ āĻšā§āϝāĻžāύ⧇āϞāĻ•ā§‡Â  maps āĻāĻŦāĻ‚ āĻ¸ā§āϞāĻžāχāϏ āĻāϰ āĻŽāϤ make āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻĄāĻŋāĻĢāĻžāχāύ āĻ•āϰāĻž āĻšā§ŸāĨ¤

āĻāĻ•āϟāĻŋ āωāĻĻāĻžāĻšāϰāĻŖ āĻĻ⧇āĻ–āĻž āϝāĻžāĻ• :

				
					  package main

   import "fmt"

   func main() { 
       var ch chan int
       if ch == nil {
           fmt.Println("channel ch is nil, Going to define it")
           ch = make(chan int)
           fmt.Printf("Type of a is %T", ch)
       }
   }
   
   Output :
   channel ch is nil, Going to define it 
   Type of ch is chan int



				
			

āωāĻĒāϰ⧇āϰ āωāĻĻāĻžāĻšāϰāϪ⧇, āφāĻŽāϰāĻž āĻāĻ•āϟāĻŋ nil āĻšā§āϝāĻžāύ⧇āϞ ch āĻĄāĻŋāĻĢāĻžāχāύ āĻ•āϰ⧇āĻ›āĻŋ, āϤāĻžāϰāĻĒāϰ āĻšā§‡āĻ• āĻ•āϰ⧇āĻ›āĻŋ ch nil āĻ•āĻŋāύāĻžāĨ¤ āϝ⧇āĻšā§‡āϤ⧁ ch āĻāĻ•āϟāĻž nil āĻšā§āϝāĻžāύ⧇āϞ āϤāĻžāχ if  āĻāϰ āĻ­āĻŋāϤāϰ⧇ āĻĒā§āϰāĻŦ⧇āĻļ āĻ•āϰ⧇āϛ⧇ “channel ch is nil, Going to define it” āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻšā§Ÿā§‡āϛ⧇, āϤāĻžāϰāĻĒāϰ make āĻĻāĻŋā§Ÿā§‡ āĻšā§āϝāĻžāύ⧇āϞ ch āϕ⧇ āĻĄāĻŋāĻĢāĻžāχāύ āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇ āĻāĻŦāĻ‚ āĻšā§āϝāĻžāύ⧇āϞ ch āĻāϰ āϟāĻžāχāĻĒ āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤Â 

 āύāĻŋāĻŽā§āύ⧇āϰ āϏāĻŋāύāĻŸā§āϝāĻžāĻ•ā§āϏ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻšā§āϝāĻžāύ⧇āϞ⧇ āĻĄāĻžāϟāĻž āϏ⧇āĻ¨ā§āĻĄ āĻāĻŦāĻ‚ āϰāĻŋāϏāĻŋāĻ­ āĻšā§Ÿā§‡ āĻĨāĻžāϕ⧇ : 

				
					

   ch <- data // write or send to channel a
   data := <- ch // read or receive from channel a 
				
			

āĻšā§āϝāĻžāύ⧇āϞ āĻ āĻĄāĻžāϟāĻž āϏ⧇āĻ¨ā§āĻĄ āĻāĻŦāĻ‚ āϰāĻŋāϏāĻŋāĻ­ āĻŦāĻžāχ āĻĄāĻŋāĻĢāĻ˛ā§āϟ āĻŦā§āϞāĻ•āĻŋāĻ‚ āĻšā§Ÿā§‡ āĻĨāĻžāϕ⧇āĨ¤ āĻ…āĻ°ā§āĻĨāĻžā§Ž āϝāĻ–āύ āĻĄāĻžāϟāĻž āϏ⧇āĻ¨ā§āĻĄ āĻ•āϰāĻž āĻšā§Ÿ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āϏ⧇āϟāĻž āϰāĻŋāϏāĻŋāĻ­ āĻ•āϰāĻžāϰ āφāĻ— āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻšā§āϝāĻžāύ⧇āϞ āϟāĻŋ āĻŦā§āϞāĻ• āĻĨāĻžāϕ⧇āĨ¤ āĻāĻ•āχ āĻ­āĻžāĻŦ⧇ āĻĄāĻžāϟāĻž āϰāĻŋāϏāĻŋāĻ­ āύāĻž āĻšāĻ“ā§ŸāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĄāĻžāϟāĻž āϏ⧇āĻ¨ā§āĻĄ āĻŦāĻ¨ā§āϧ āĻĨāĻžāϕ⧇ āĻ…āĻ°ā§āĻĨāĻžā§ŽÂ  āĻšā§āϝāĻžāύ⧇āϞ āĻŦā§āϞāĻ• āĻĨāĻžāϕ⧇āĨ¤ āĻ āϜāĻ¨ā§āϝāχ āĻŦāϞāĻž āĻšā§Ÿ āĻšā§āϝāĻžāύ⧇āϞ āĻŦāĻžāχ āĻĄāĻŋāĻĢāĻ˛ā§āϟ āĻŦā§āϞāĻ•āĻŋāĻ‚āĨ¤

āĻāĻ–āύ āĻ•āĻŋāϛ⧁ āωāĻĻāĻžāĻšāϰāϪ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻšā§āϝāĻžāύ⧇āϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻāϰ āĻ•āĻŽāĻŋāωāύāĻŋāϕ⧇āĻļāύ āĻŦ⧁āĻāĻžāϰ āĻšā§‡āĻˇā§āϟāĻž āĻ•āϰāĻŋāĨ¤ [4.1.2] āĻāϰ āĻĻā§āĻŦāĻŋāĻ¤ā§€ā§Ÿ āωāĻĻāĻžāĻšāϰāĻŖāϟāĻž āĻāĻŦāĻžāϰ āφāĻŽāϰāĻž āĻšā§āϝāĻžāύ⧇āϞ āĻāϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ āĻ•āϰāĻŦā§‹ : 

				
					package main

   import ( 
       "fmt"
   )

   func hello(done chan bool) { 
       fmt.Println("Hello world Goroutine")
       done <- true   // signal that the work is done
   }
   func main() { 
       done := make(chan bool)
       go hello(done)
       <-done   // wait for the Goroutine to finish
       fmt.Println("main function")
   }

   // Output :
   // Hello world Goroutine
   // main function
				
			

āωāĻĒāϰ⧇āϰ āωāĻĻāĻžāĻšāϰāϪ⧇, done bool āύāĻžāĻŽā§‡ āĻšā§āϝāĻžāύ⧇āϞ āϤ⧈āϰāĻŋ āĻ•āϰ⧇āĻ›āĻŋ āϏ⧇āϟāĻž hello āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻ āĻĒā§āϝāĻžāϰāĻžāĻŽāĻŋāϟāĻžāϰ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻžāϏ āĻ•āϰ⧇āĻ›āĻŋ, āĻĒāϰ⧇āϰ āϞāĻžāχāύ⧇ hello() āĻĨ⧇āϕ⧇ āĻĒāĻžāĻ āĻžāύ⧋ āĻĄāĻžāϟāĻž <-done āĻāϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ āϰāĻŋāϏāĻŋāĻ­ āĻ•āϰāϤ⧇āĻ›āĻŋ āϝāĻž done <- āĻāϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ āĻĒāĻžāĻ āĻžāύ⧋ āĻšā§Ÿā§‡āĻ›āĻŋāϞāĨ¤ āĻ…āĻ°ā§āĻĨāĻžā§Ž āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻĄāĻžāϟāĻž āϏ⧇āĻ¨ā§āĻĄ āύāĻž āĻ•āϰāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻŽā§‡āχāύ āĻĢāĻžāĻ‚āĻļāύ āĻŦā§āϞāĻ• āĻ…āĻŦāĻ¸ā§āĻĨāĻžā§Ÿ āĻĨāĻžāĻ•āĻŦ⧇āĨ¤ āĻāϤ⧇ āĻ•āϰ⧇ āφāĻŽāĻžāĻĻ⧇āϰ āφāϰ time.Sleep() āϞāĻŋāϖ⧇ āĻ…āĻĒ⧇āĻ•ā§āώāĻž āĻ•āϰāϤ⧇ āĻŦāϞāĻž āϞāĻžāϗ⧇āύāĻŋ āĻāĻŦāĻ‚ āĻŽā§‡āχāύ āĻĢāĻžāĻ‚āĻļāύ āϤāĻžāϰ āĻāĻ•ā§āϏāĻŋāĻ•āĻŋāωāĻļāύ āĻļ⧇āώ āĻ•āϰ⧇ āĻĻā§‡ā§ŸāύāĻŋāĨ¤Â Â 

āωāĻĒāϰ⧇āϰ āωāĻĻāĻžāĻšāϰāĻŖāϟāĻŋ āĻāĻ•āϟ⧁ āĻŽāĻĄāĻŋāĻĢāĻžāχ āĻ•āϰāĻž āϝāĻžāĻ• : 

				
					  package main

   import (
       "fmt"
       "time"
   )

   func hello(done chan bool) {
       fmt.Println("hello Go routine is Going to sleep")
       time.Sleep(4 * time.Second)
       fmt.Println("hello Go routine awake and Going to write to done")
       done <- true // signal that the work is done
   }
   
   func main() {
       done := make(chan bool)
       fmt.Println("Main Going to call hello Go Goroutine")
       go hello(done)
       <-done // wait for the Goroutine to finish
       fmt.Println("Main received data")
   }

   // Output :
   // Main Going to call hello Go Goroutine
   // hello Go routine is Going to sleep
   // hello Go routine awake and Going to write to done
   // Main received data

				
			

āĻāĻŦāĻžāϰ āϞāĻ•ā§āώ āĻ•āϰāĻž āϝāĻžāĻ•, āĻāχ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽā§‡ āĻĒā§āϰāĻĨāĻŽā§‡ “Main Going to call hello Go Goroutine” āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻšā§Ÿā§‡āϛ⧇,āϤāĻžāϰāĻĒāϰ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻ¸ā§āϟāĻžāĻ°ā§āϟ āĻšā§Ÿā§‡āϛ⧇ āĻāĻŦāĻ‚ “hello Go routine is Going to sleep” āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻšā§Ÿā§‡āϛ⧇āĨ¤ āĻāϟāĻŋ āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻšāĻ“āϝāĻŧāĻžāϰ āĻĒāϰ⧇, hello āĻ—ā§‹-āϰ⧁āϟāĻŋāύ 4 āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡āϰ āϜāĻ¨ā§āϝ Sleep āĻ āϝāĻžāĻŦ⧇ āĻāĻŦāĻ‚ āĻāχ āϏāĻŽāϝāĻŧ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻŽā§‡āχāύ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻŦā§āϞāĻ• āĻšāϝāĻŧ⧇ āϝāĻžāĻŦ⧇ āĻ•āĻžāϰāĻŖ āĻāϟāĻŋ āĻšā§āϝāĻžāύ⧇āϞ āĻĨ⧇āϕ⧇ āϰ⧇āϏāĻĒāĻ¨ā§āϏ⧇āϰ āϜāĻ¨ā§āϝ āĻ…āĻĒ⧇āĻ•ā§āώāĻž āĻ•āϰāϛ⧇āĨ¤ 4 āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻĒāϰ “hello Go routine awake and Going to write to done” āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻšāĻŦ⧇ āĻāĻŦāĻ‚ āϰ⧇āϏāĻĒāĻ¨ā§āϏ āφāϏāĻŦ⧇ āϤāĻ–āύ “Main received data” āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻšāĻŦ⧇ āϏāĻžāĻĨ⧇ āϏāĻžāĻĨ⧇ āĻŽā§‡āχāύ āĻĢāĻžāĻ‚āĻļāύāĻ“ āĻŦāĻ¨ā§āϧ āĻšā§Ÿā§‡ āϝāĻžāĻŦ⧇āĨ¤

[ā§Ē.⧍.ā§Ē] Unbuffered āĻšā§āϝāĻžāύ⧇āĻ˛Â  āϕ⧀ ?

āφāĻŽāϰāĻž āφāϗ⧇āχ āĻŦāϞ⧇āĻ›āĻŋ āĻšā§āϝāĻžāύ⧇āϞ āĻĻ⧁āχ āĻĒā§āϰāĻ•āĻžāϰ Unbuffered āĻāĻŦāĻ‚ Buffered āĻšā§āϝāĻžāύ⧇āϞ āĨ¤ āĻāĻ–āύ āφāĻŽāϰāĻž āϜāĻžāύāĻŦ Unbuffered āĻšā§āϝāĻžāύ⧇āϞ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āĨ¤ āφāϏāϞ⧇ āĻšā§āϝāĻžāύ⧇āϞ āĻŦāĻžāχ āĻĄāĻŋāĻĢāĻ˛ā§āϟ Unbuffered āĻĨāĻžāϕ⧇āĨ¤ Unbuffered āĻšā§āϝāĻžāύ⧇āϞ āĻ āĻ­ā§āϝāĻžāϞ⧁ āϏ⧇āĻ¨ā§āĻĄāĻŋāĻ‚ (chan <- )  āĻāϰ āĻ•āϰ⧇āĻ¸ā§āĻĒāĻ¨ā§āĻĄāĻŋāĻ‚ āĻ­ā§āϝāĻžāϞ⧁ āϰāĻŋāϏāĻŋāĻ­āĻžāϰ (<- chan) āĻĨāĻžāĻ•āĻŦ⧇āĨ¤

				
					  package main

   import (
       "fmt"
       "time"
   )
   // ---send data into a channel---
   func sendData(ch chan string) {
       fmt.Println("Sending a string into channel...")


       ch <- "Hello"
       fmt.Println("String has been retrieved from channel...")
   }

   // ---getting data from the channel---
   func getData(ch chan string) {
       time.Sleep(2 * time.Second)
       fmt.Println("String retrieved from channel:", <-ch)
   }

   func main() {
       ch := make(chan string)
       go sendData(ch)
       go getData(ch)
       fmt.Scanln()
   }

   // Output :
   // Sending a string into channel...
   // String retrieved from channel: Hello
   // String has been retrieved from channelâ€Ļ
				
			
āĻāĻ–āĻžāύ⧇ āφāĻŽāϰāĻž main() āĻĢāĻžāĻ‚āĻļāύ⧇ make() āĻĢāĻžāĻ‚āĻļāύ⧇āϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ string āϟāĻžāχāĻĒ⧇āϰ āĻšā§āϝāĻžāύ⧇āϞ ch āϤ⧈āϰāĻŋ āĻ•āϰ⧇āĻ›āĻŋāĨ¤ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻāϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ sendData() āĻāĻŦāĻ‚ getData()  āĻĢāĻžāĻ‚āĻļāύ āĻ•āϞ āĻ•āϰ⧇āĻ›āĻŋāĨ¤Â  sendData()  āĻĢāĻžāĻ‚āĻļāύ “Sending a string into channelâ€Ļ” āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻ•āϰ⧇āϛ⧇ āĻāĻ•āχ āϏāĻŽā§Ÿ getData() āĻĢāĻžāĻ‚āĻļāύāĻ“ āĻ•āϞ āĻšā§Ÿā§‡āϛ⧇ āϏ⧇ āϏāĻžāĻĨ⧇ āϏāĻžāĻĨ⧇ time.Sleep() āĻĢāĻžāĻ‚āĻļāύ āĻĒā§‡ā§Ÿā§‡Â  2 āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻ“ā§Ÿā§‡āϟāĻŋāĻ‚ āĻ āϚāϞ⧇ āϗ⧇āϛ⧇ āĨ¤Â  2 āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻĒāϰ āĻ­ā§āϝāĻžāϞ⧁ āϰāĻŋāϏāĻŋāĻ­ āĻ•āϰ⧇ “String retrieved from channel : Hello”  āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻ•āϰ⧇āϛ⧇āĨ¤

[ā§Ē.⧍.ā§Ģ] Buffered āĻšā§āϝāĻžāύ⧇āĻ˛Â  āϕ⧀ ?

Buffered āĻšā§āϝāĻžāύ⧇āĻ˛Â  āĻāĻ• āϧāϰāύ⧇āϰ āĻšā§āϝāĻžāύ⧇āϞ āϝāĻžāϰ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ Buffer āĻĨāĻžāĻ•āĻŦ⧇ āϝ⧇āĻ–āĻžāύ⧇ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϏāĻ‚āĻ–ā§āϝāĻ• āĻ­ā§āϝāĻžāϞ⧁ āĻˇā§āĻŸā§‹āϰ āĻ•āϰ⧇ āϰāĻžāĻ–āϤ⧇ āĻĒāĻžāϰ⧇ āĻ•āϰ⧇āĻ¸ā§āĻĒāĻ¨ā§āĻĄāĻŋāĻ‚ āϕ⧋āύ āϰāĻŋāϏāĻŋāĻ­āĻžāϰ āĻ›āĻžā§œāĻžāχāĨ¤ āϝāĻ–āύ āφāĻŽāĻžāĻĻ⧇āϰ āĻāĻ•āϟāĻŋ Go āϰ⧁āϟāĻŋāύ⧇ āĻĄā§‡āϟāĻž āĻĒā§āϰāĻ¸ā§āϤ⧁āϤ āĻ•āϰāϤ⧇ āĻšā§Ÿ āĻāĻŦāĻ‚ āĻ…āĻ¨ā§āϝ Go āϰ⧁āϟāĻŋāύ⧇ āĻĄā§‡āϟāĻž āϏāϰāĻŦāϰāĻžāĻš āĻ•āϰāϤ⧇ āĻšā§Ÿ āϤāĻ–āύ āφāĻŽāϰāĻž āĻŦāĻžāĻĢāĻžāϰ āĻšā§āϝāĻžāύ⧇āϞāϗ⧁āϞāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋāĨ¤Â Â 

 

Buffered āĻšā§āϝāĻžāύ⧇āϞ āϏāĻŋāύāĻŸā§āϝāĻžāĻ•ā§āϏ : 

gochan_buffer

āωāĻĻāĻžāĻšāϰāĻŖ : 

				
					 package main

   import (
       "fmt"
   )

   func main() {
       linkChannel := make(chan string, 5)
       go ping(linkChannel)
       fmt.Println(<-linkChannel)
       fmt.Println(<-linkChannel)
       fmt.Println(<-linkChannel)
   }

  func ping(c chan string) {
       links := []string{"https://www.golinuxcloud.com/", "https://www.tesla.com/", "https://www.google.com/"}
       for _, link := range links {
           c <- link
       }
   }

   // Output :
   // https://www.golinuxcloud.com/
   // https://www.tesla.com/
   // https://www.google.com/

				
			

āωāĻĒāϰ⧇āϰ āωāĻĻāĻžāĻšāϰāϪ⧇, āĻāĻ•āϟāĻŋ buffered āĻšā§āϝāĻžāύ⧇āϞ linkChannel āϝāĻž āĻ—ā§‹-āϰ⧁āϟāĻŋāύ ping āĻāϰ āϏāĻžāĻĨ⧇ āĻĒāĻžāĻ āĻžāύ⧋ āĻšā§Ÿā§‡āϛ⧇āĨ¤ ping() āĻĢāĻžāĻ‚āĻļāύ āĻĨ⧇āϕ⧇ āĻĒāĻžāĻ āĻžāύ⧋ āĻ­ā§āϝāĻžāϞ⧁ main() āĻĢāĻžāĻ‚āĻļāύ āϰāĻŋāϏāĻŋāĻ­ āĻ•āϰ⧇āϛ⧇ āĨ¤Â 

[ āύ⧋āϟ – buffered āĻšā§āϝāĻžāύ⧇āϞ āĻĒā§āϝāĻžāύāĻŋāĻ• āĻāĻŦāĻ‚ āĻāϰāϰ āϰāĻŋāϟāĻžāĻ°ā§āύ āĻ•āϰ⧇ āϝāĻ–āύ āϰāĻŋāϏāĻŋāĻ­āĻžāϰ(<- link Channel ) āĻāĻŽā§āĻĒāϟāĻŋ āĻĨāĻžāϕ⧇ ] 

[ā§Ē.⧍.ā§Ŧ] āĻšā§āϝāĻžāύ⧇āϞ āĻ Select 

Go-āϤ⧇, āϏāĻŋāϞ⧇āĻ•ā§āϟ āĻ¸ā§āĻŸā§‡āϟāĻŽā§‡āĻ¨ā§āϟ āĻ…āύ⧇āĻ• āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇āχ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ, āĻŦāĻŋāĻļ⧇āώ āĻ•āϰ⧇ āĻŽāĻžāĻ˛ā§āϟāĻŋāĻĒāϞ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϞ⧇ āϤāĻ–āύ āĻ…āύ⧇āĻ• āĻĄāĻžāϟāĻž āĻļā§‡ā§ŸāĻžāϰ āĻšā§Ÿ, āϤāĻ–āύ āĻāϗ⧁āϞ⧋ āϏāĻŋāĻ•ā§ā§Ÿā§‡āĻ¨ā§āϏ āĻ…āύ⧁āϏāĻžāϰ⧇ āĻĒāĻžāĻ“ā§ŸāĻžāϰ āϜāĻ¨ā§āϝ āϏāĻŋāϞ⧇āĻ•ā§āϟ āĻ¸ā§āĻŸā§‡āϟāĻŽā§‡āĻ¨ā§āϟ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§ŸāĨ¤ āĻšā§āϝāĻžāύ⧇āϞ⧇ āĻŽāĻžāĻ˛ā§āϟāĻŋāĻĒāϞ āĻĄāĻžāϟāĻž āϏāĻŋāĻ•ā§ā§Ÿā§‡āĻ¨ā§āϏ āĻ…āύ⧁āĻ¸ā§āĻŦāĻžāϰ⧇ āĻĒāĻžāĻ“ā§ŸāĻžāϰ āϜāĻ¨ā§āϝāĻ“ āφāĻŽāϰāĻž āϏāĻŋāϞ⧇āĻ•ā§āϟ āĻ¸ā§āĻŸā§‡āϟāĻŽā§‡āĻ¨ā§āϟ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋāĨ¤ āϏāĻŋāϞ⧇āĻ•ā§āϟ āĻ¸ā§āĻŸā§‡āϟāĻŽā§‡āĻ¨ā§āϟ āĻ…āύ⧇āĻ•āϟāĻžāχ switch āĻ¸ā§āĻŸā§‡āϟāĻŽā§‡āĻ¨ā§āĻŸā§‡āϰ āĻŽāϤ⧋āχ āϝāĻžāϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ āĻŽāĻžāĻ˛ā§āϟāĻŋāĻĒāϞ āĻšā§āϝāĻžāύ⧇āϞ āĻāϰ āϏāĻžāĻĨ⧇ āĻ•āĻŽāĻŋāωāύāĻŋāϕ⧇āĻļāύ āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤

āϏāĻŋāϞ⧇āĻ•ā§āϟ āĻ¸ā§āĻŸā§‡āϟāĻŽā§‡āĻ¨ā§āĻŸā§‡āϰ āϏāĻŋāύāĻŸā§āϝāĻžāĻ•ā§āϏ : 

				
					 select {
       case <-ch1:                         // Discard received value
           fmt.Println("Got something")
      
       case x := <-ch2:                    // Assign received value to x
           fmt.Println(x)
      
       case ch3 <- y:                      // Send y to channel
           fmt.Println(y)
      
       default:
           fmt.Println("None of the above")
       }

				
			

āωāĻĒāϰ⧇āϰ āωāĻĻāĻžāĻšāϰāϪ⧇, āĻšā§āϝāĻžāύ⧇āϞ ch1 āϝāĻĻāĻŋ āϰāĻŋāϏāĻŋāĻ­ āĻ¸ā§āϟāĻžāĻŸā§‡ āĻĨāĻžāϕ⧇ āϤāĻžāĻšāϞ⧇ āϏ⧇ “Got something” āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻ•āϰāĻŦ⧇,

āĻšā§āϝāĻžāύ⧇āϞ ch2 āĻ­ā§āϝāĻžāϞ⧁ āϰāĻŋāϏāĻŋāĻ­ āĻ•āϰ⧇ x āĻ…ā§āϝāĻžāϏāĻžāχāύ āĻ•āϰ⧇ āϤāĻžāϰāĻĒāϰ āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻ•āϰāĻŦ⧇, āĻšā§āϝāĻžāύ⧇āϞ ch3, y āĻāϰ āĻ­ā§āϝāĻžāĻ˛ā§Â  āϏ⧇āĻ¨ā§āĻĄ āĻ•āϰāĻŦ⧇ āφāϰ āĻāχ āĻ•āĻ¨ā§āĻĄāĻŋāĻļāϗ⧁āϞ⧋ āϏāĻ¤ā§āϝ āύāĻž āĻšāϞ⧇ default āĻ “None of the above” āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻšāĻŦ⧇āĨ¤

[ā§Ē.⧍.ā§­] āĻ•ā§āϞ⧋āϜāĻŋāĻ‚ āĻšā§āϝāĻžāύ⧇āϞ(Closing Channel )

āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽā§‡āϰ āϝ⧇āĻ–āĻžāύ⧇ āϝ⧇ āĻšā§āϝāĻžāύ⧇āϞ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§Ÿ, āϏ⧇ āϜāĻžā§ŸāĻ—āĻž āĻšāϤ⧇āχ āĻšā§āϝāĻžāύ⧇āϞāϟāĻŋ āĻŦāĻ¨ā§āϧ āĻ•āϰāĻž āϏāĻŽā§āĻ­āĻŦ, close() āĻĢāĻžāĻ‚āĻļāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤ āĻšā§āϝāĻžāύ⧇āϞāϟāĻŋ āĻŦāĻ¨ā§āϧ āĻ•āϰāĻž āĻšāϝāĻŧ⧇āϛ⧇ āĻ•āĻŋāύāĻž āϤāĻž āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰāϤ⧇ āĻšā§āϝāĻžāύ⧇āϞ āĻĨ⧇āϕ⧇ āĻĄāĻžāϟāĻž āĻ—ā§āϰāĻšāĻŖ āĻ•āϰāĻžāϰ āϏāĻŽāϝāĻŧ āϰāĻŋāϏāĻŋāĻ­āĻžāϰ āĻāĻ•āϟāĻŋ āĻ…āϤāĻŋāϰāĻŋāĻ•ā§āϤ āĻ­āĻžāϰāĻŋ⧟āĻžāĻŦāϞ āĻšā§‡āĻ•āĻžāϰ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āϝ⧇āĻŽāύ – 

				
					v, ok := <- ch
				
			

āϝāĻĻāĻŋ ok āĻ¸ā§āĻŸā§‡āϟāĻŽā§‡āĻ¨ā§āϟ true āĻšā§Ÿ āϤāĻžāĻšāϞ⧇ āϰāĻŋāϏāĻŋāĻ­āĻžāϰ āĻŦ⧁āĻāĻŦ⧇ āĻāϟāĻž āϏāĻ āĻŋāĻ• āϏ⧇āĻ¨ā§āĻĄāĻžāϰ āĻĨ⧇āϕ⧇ āĻĄāĻžāϟāĻž āĻāϏ⧇āϛ⧇ āφāϰ ok āĻ¸ā§āĻŸā§‡āϟāĻŽā§‡āĻ¨ā§āϟ false āĻšāϞ⧇ āϰāĻŋāϏāĻŋāĻ­āĻžāϰ āĻŦ⧁āĻāĻŦ⧇ āĻāϟāĻž āĻšā§āϝāĻžāύ⧇āϞ āĻŦāĻ¨ā§āϧ āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤ āφāϰ āĻāĻ•āϟāĻž āĻŦāĻ¨ā§āϧ āĻšā§āϝāĻžāύ⧇āϞ āĻĨ⧇āϕ⧇ āϏāĻ°ā§āĻŦāĻĻāĻžāχ 0 āĻ…āĻĨāĻŦāĻž nil āĻŽāĻžāύ āφāϏāĻŦ⧇āĨ¤

 

āύāĻŋāĻšā§‡āϰ āωāĻĻāĻžāĻšāϰāĻŖāϟāĻŋ āĻĻ⧇āĻ–āĻž āϝāĻžāĻ• –

				
					 package main

   import ( 
       "fmt"
   )

   func producer(chnl chan int) { 
       for i := 0; i < 10; i++ {
           chnl <- i
       }
       close(chnl)
   }
   
   func main() { 
       ch := make(chan int)
       go producer(ch)
       for {
           v, ok := <-ch
           if ok == false {
               break
           }
           fmt.Println("Received ", v, ok)
       }
   }
   // Output:
   // Received  0 true 
   // Received  1 true 
   // Received  2 true 
   // Received  3 true 
   // Received  4 true 
   // Received  5 true 
   // Received  6 true 
   // Received  7 true 
   // Received  8 true 
   // Received  9 true

				
			

āĻāĻ–āĻžāύ⧇ 0 āĻĨ⧇āϕ⧇ 9 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻšā§Ÿā§‡āϛ⧇, āϝāĻ–āύ ok āĻ­ā§āϝāĻžāϞ⧁ āĻŽāĻŋāĻĨā§āϝāĻž āĻĒā§‡ā§Ÿā§‡āϛ⧇ āϤāĻ–āύāχ āĻšā§āϝāĻžāύ⧇āϞ āĻŦāĻ¨ā§āϧ āĻ•āϰ⧇ āĻĻāĻŋā§Ÿā§‡āϛ⧇āĨ¤ main() āĻĢāĻžāĻ‚āĻļāύ⧇ ok āĻŽāĻŋāĻĨā§āϝāĻž āĻšāĻ“ā§ŸāĻžāϰ āϏāĻžāĻĨ⧇ āϏāĻžāĻĨ⧇āχ break āĻ•āϰ⧇ āĻĻāĻŋā§Ÿā§‡āϛ⧇āĨ¤Â