Vivasoft-logo

[ā§Ē] āĻ•āύāĻ•āĻžāϰ⧇āĻ¨ā§āϏāĻŋ (Concurrency)

āĻāχ āĻĒāĻ°ā§āϝāĻžā§Ÿā§‡ āφāĻŽāϰāĻž āĻĒāϰāĻŋāϚāĻŋāϤ āĻšāĻŦā§‹ Go āĻ•āύāĻ•āĻžāϰ⧇āĻ¨ā§āϏāĻŋāϰ āϏāĻžāĻĨ⧇āĨ¤ Go āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āĻ āϖ⧁āĻŦāχ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āĻāĻ•āϟāĻŋ āĻ…āĻ‚āĻļ āĻšāϞ āĻ•āύāĻ•āĻžāϰ⧇āĻ¨ā§āϏāĻŋāĨ¤ āφāĻŽāϰāĻž āĻ…āύ⧇āϕ⧇āχ āĻ•āύāĻ•āĻžāϰ⧇āĻ¨ā§āϏāĻŋ āĻāĻŦāĻ‚ āĻĒā§āϝāĻžāϰāĻžāϞ⧇āϞāĻŋāϜāĻŽ āĻļāĻŦā§āĻĻ āĻĻ⧁āϟāĻŋ āύāĻŋā§Ÿā§‡ āĻĻā§āĻŦāĻŋāϧāĻžāĻ¨ā§āĻŦāĻŋāϤ āĻĨāĻžāĻ•āĻŋāĨ¤ āφāĻļāĻž āϰāĻžāĻ–āĻ›āĻŋ, āĻŦ⧁āϟāĻ•ā§āϝāĻžāĻŽā§āĻĒ⧇āϰ āĻāχ āĻ…āĻ‚āĻļ⧇ āĻ•āύāĻ•āĻžāϰ⧇āĻ¨ā§āϏāĻŋ āĻāĻŦāĻ‚ āĻĒā§āϝāĻžāϰāĻžāϞ⧇āϞāĻŋāϜāĻŽ āĻāϰ āϧāĻžāϰāĻŖāĻž āĻĒāϰāĻŋāĻˇā§āĻ•āĻžāϰ āĻšā§Ÿā§‡ āϝāĻžāĻŦ⧇ āĻāĻŦāĻ‚ Go āϤ⧇ āĻāϰ āĻĒā§āĻ°ā§Ÿā§‹āĻ— āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇āĻ“ āϧāĻžāϰāĻŖāĻž āĻĒā§‡ā§Ÿā§‡ āϝāĻžāĻŦā§‹āĨ¤

 

āĻ•āύāĻ•āĻžāϰ⧇āĻ¨ā§āϏāĻŋ āĻšāϞ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻž āϝ⧇āĻ–āĻžāύ⧇ āĻ…āύ⧇āĻ•āϗ⧁āϞ⧋ āĻ•āĻžāϜ āĻŦāĻž āĻ…āĻĒāĻžāϰ⧇āĻļāύ āĻāĻ•āχāϏāĻžāĻĨ⧇ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻāĻ•āχ āϏāĻŽā§Ÿā§‡ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤ āϝ⧇āĻŽāύ, āĻāĻ•āϜāύ āĻļā§āϰāĻŽāĻŋāĻ• āϰāĻ™ āĻ•āϰāĻžāϰ āĻ•āĻžāϜ āĻāĻŦāĻ‚ āĻĻā§‡ā§ŸāĻžāϞ āĻŦāĻžāύāĻžāύ⧋āϰ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻāĻ•āχ āϏāĻŽā§Ÿā§‡ āĻĻā§‡ā§ŸāĻžāϞ āĻŦāĻžāύāĻžāύ⧋ āĻāĻŦāĻ‚ āϰāĻ‚ āĻ•āϰāĻžāϰ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤


             āĻĒā§āϝāĻžāϰāĻžāϞ⧇āϞāĻŋāϜāĻŽ āĻšāϞ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻž āϝ⧇āĻ–āĻžāύ⧇ āĻ…āύ⧇āĻ•āϗ⧁āϞ⧋ āĻ•āĻžāϜ āĻāĻ•āχ āϏāĻžāĻĨ⧇ āĻāĻŦāĻ‚ āĻāĻ•āχ āϏāĻŽā§Ÿā§‡ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āϝ⧇āĻŽāύ, āĻāĻ•āϜāύ āϰāĻžāρāϧ⧁āύāĻŋ āĻ•āĻŋāĻ¨ā§āϤ⧁ āϚāĻžāχāϞ⧇āχ āĻāĻ•āĻžāϧāĻŋāĻ• āϚ⧁āϞāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻāĻ•āϏāĻžāĻĨ⧇ āĻ•ā§Ÿā§‡āĻ•āϟāĻŋ āĻ–āĻžāĻŦāĻžāϰ āϰāĻžāĻ¨ā§āύāĻž āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āύ, āĻāĻ–āĻžāύ⧇ āĻāĻ•āϟāĻŋ āĻ–āĻžāĻŦāĻžāϰ āϰāĻžāĻ¨ā§āύāĻž āĻšāĻ“ā§ŸāĻžāϰ āϜāĻ¨ā§āϝ āφāϰ⧇āĻ•āϟāĻŋ āĻ–āĻžāĻŦāĻžāϰ āϰāĻžāĻ¨ā§āύāĻž āĻļ⧇āώ āĻšāĻŦāĻžāϰ āĻĒā§āĻ°ā§Ÿā§‹āϜāύ āύ⧇āχāĨ¤

Go āĻāϰ āύāĻŋāϜāĻ¸ā§āĻŦ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻāĻŦāĻ‚ āĻšā§āϝāĻžāύ⧇āϞ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻ•āύāĻ•āĻžāϰ⧇āĻ¨ā§āϏāĻŋ āĻ…āĻ°ā§āϜāύ āĻ•āϰ⧇ āĻĨāĻžāϕ⧇āĨ¤ āĻāχ āĻĒāĻ°ā§āϝāĻžā§Ÿā§‡ āφāĻŽāϰāĻž āĻ—ā§‹-āϰ⧁āϟāĻŋāύ, āĻšā§āϝāĻžāύ⧇āϞ, āĻ“āϝāĻŧ⧇āϟāĻ—ā§āϰ⧁āĻĒ,  āϏāĻŋāĻ™ā§āĻ•āĻ—ā§āϰ⧁āĻĒ āύāĻŋā§Ÿā§‡ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻŦā§‹āĨ¤

[ā§Ē.ā§§] āĻ—ā§‹-āϰ⧁āϟāĻŋāύ (Goroutine)

  āφāĻŽāϰāĻž āφāϗ⧇āχ āĻŦāϞ⧇āĻ›āĻŋ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡, Go āĻ•āύāĻ•āĻžāϰ⧇āĻ¨ā§āϏāĻŋ āĻ…āĻ°ā§āϜāύ āĻ•āϰ⧇ āĻĨāĻžāϕ⧇āĨ¤ āϤāĻžāĻšāϞ⧇ āĻĻ⧇āĻ–āĻž āϝāĻžāĻ• āϕ⧀ āĻ­āĻžāĻŦ⧇ āφāĻŽāϰāĻž āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻ•āύāĻ•āĻžāϰ⧇āĻ¨ā§āϏāĻŋ āĻ…āĻ°ā§āϜāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋāĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āϤāĻžāϰ āφāϗ⧇ āφāĻŽāĻžāĻĻ⧇āϰ āϜāĻžāύāϤ⧇ āĻšāĻŦ⧇ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āϕ⧀, āĻāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāĻŦāĻ‚ āĻ•āĻžāϜāĨ¤

[ā§Ē.ā§§.ā§§] āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āϕ⧀ ?

āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻšāϞ⧋ āĻĢāĻžāĻ‚āĻļāύ āĻŦāĻž āĻŽā§‡āĻĨāĻĄ āϝāĻž āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ āĻĢāĻžāĻ‚āĻļāύ āĻŦāĻž āĻŽā§‡āĻĨāĻĄā§‡āϰ āϏāĻžāĻĨ⧇ āĻāĻ•āχāϏāĻŽā§Ÿā§‡ āĻŦāĻž āĻāĻ•āχāϏāĻžāĻĨ⧇ āϰāĻžāύ āĻ•āϰ⧇āĨ¤ āφāĻŽāϰāĻž āϚāĻžāχāϞ⧇ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āϕ⧇ thread āĻāϰ āϏāĻžāĻĨ⧇ āϤ⧁āϞāύāĻž āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŋāĨ¤ āĻāĻ•āϟāĻŋ thread āĻāϰ āϤ⧁āϞāύāĻžā§Ÿ āĻāĻ•āϟāĻŋ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āϤ⧈āϰāĻŋāϤ⧇, āϰāĻŋāϏ⧋āĻ°ā§āϏ⧇āϰ āĻĒā§āĻ°ā§Ÿā§‹āϜāĻ¨ā§€ā§ŸāϤāĻž āĻ…āύ⧇āĻ• āĻ•āĻŽ āĻāĻŦāĻ‚ āĻāĻ•āϟāĻŋ āϏāĻŋāĻ™ā§āϗ⧇āϞ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ⧇ āĻ…āύ⧇āĻ•āϗ⧁āϞ⧋ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻāĻ•āχāϏāĻŽā§Ÿā§‡ āĻ“ āĻāĻ•āχāϏāĻžāĻĨ⧇ āϚāϞāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

[ā§Ē.ā§§.⧍]  āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ—ā§‹-āϰ⧁āϟāĻŋāĻ¨Â  āĻļ⧁āϰ⧁ āĻ•āϰāĻŦā§‹ ?

āϭ⧟ āĻĒāĻžāĻŦāĻžāϰ āϕ⧋āύ āĻ•āĻŋāϛ⧁ āύ⧇āχ āĻ•āĻžāϰāĻŖ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻļ⧁āϰ⧁ āĻ•āϰāĻž āϖ⧁āĻŦāχ āϏāĻšāϜāĨ¤ āĻĢāĻžāĻ‚āĻļāύ āĻŦāĻž āĻŽā§‡āĻĨāĻĄā§‡āϰ āφāϗ⧇ go āĻ•āĻŋāĻ“ā§ŸāĻžāĻ°ā§āĻĄ āϞāĻŋāϖ⧇ āĻĻāĻŋāϞ⧇āχ āύāϤ⧁āύ āĻ—ā§‹-āϰ⧁āϟāĻŋāĻ¨Â  āϤ⧈āϰāĻŋ āĻšā§Ÿā§‡ āϝāĻžāĻŦ⧇āĨ¤ āύāĻŋāĻšā§‡ āωāĻĻāĻžāĻšāϰ⧇āύ⧇āϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ āĻĻ⧇āĻ–āĻž āϝāĻžāĻ• – 

				
					 package main

   import ( 
       "fmt"
   )

   func hello() { 
       fmt.Println("Hello world Goroutine")
   }
   func main() { 
       go hello()
       fmt.Println("main function")
   }

   //Output :
   //main function
   //Program exited.

				
			

  āωāĻĒāϰ⧇āϰ āωāĻĻāĻžāĻšāϰāϪ⧇, go hello() āĻĻā§āĻŦāĻžāϰāĻž āύāϤ⧁āύ āĻ—ā§‹-āϰ⧁āϟāĻŋāĻ¨Â  āϤ⧈āϰāĻŋ āĻšā§Ÿā§‡āϛ⧇āĨ¤ āĻāĻ–āύ hello() āĻĢāĻžāĻ‚āĻļāύāϟāĻŋ main() āĻĢāĻžāĻ‚āĻļāύ⧇āϰ āϏāĻžāĻĨ⧇ āĻāĻ•āχāϏāĻžāĻĨ⧇ āϰāĻžāύ āĻ•āϰāĻŦ⧇āĨ¤ main() āĻĢāĻžāĻ‚āĻļāύ āύāĻŋāĻœā§‡āĻ“ āĻāĻ•āϟāĻŋ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻšāĻŋāϏ⧇āĻŦ⧇ āϰāĻžāύ āĻšā§Ÿ āϝāĻžāϕ⧇ āĻŦāϞāĻž āĻšā§Ÿ āĻŽā§‡āχāύ āĻ—ā§‹-āϰ⧁āϟāĻŋāύāĨ¤Â Â 

 āωāĻĒāϰ⧇āϰ āφāωāϟāĻĒ⧁āĻŸā§‡āϰ āĻĻāĻŋāϕ⧇ āϝāĻĻāĻŋ āϞāĻ•ā§āώ āĻ•āϰāĻŋ āϤāĻžāĻšāϞ⧇ āĻĻ⧇āĻ–āϤ⧇ āĻĒāĻžāĻŦā§‹ āĻļ⧁āϧ⧁ “main function” āϞ⧇āĻ–āĻžāϟāĻŋ āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻšā§Ÿā§‡āϛ⧇āĨ¤ āϤāĻžāĻšāϞ⧇ āĻ•āĻŋ āφāĻŽāĻžāĻĻ⧇āϰ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻ•āĻžāϜ āĻ•āϰ⧇āύāĻŋ ? āĻŦāĻŋāώ⧟āϟāĻž āφāϏāϞ⧇ āĻāĻŽāύ āύāĻž, āĻāϟāĻž āĻŦ⧁āĻāϤ⧇ āĻšāϞ⧇ āφāϗ⧇ āφāĻŽāĻžāĻĻ⧇āϰ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻāϰ āĻĻ⧁āχāϟāĻž āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ āĻŦ⧁āĻāϤ⧇ āĻšāĻŦ⧇āĨ¤ āĻĻ⧇āĻ–āĻž āϝāĻžāĻ• āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ āĻĻ⧁āϟāĻŋ āϕ⧀ – 

 

ā§§āĨ¤ āϝāĻ–āύ āĻāĻ•āϟāĻŋ āύāϤ⧁āύ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻļ⧁āϰ⧁ āĻšāϝāĻŧ, āϤāĻ–āύ āĻ…āĻ¨ā§āϝ āĻĢāĻžāĻ‚āĻļāύāϗ⧁āϞ⧋ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āϰāĻŋāϟāĻžāĻ°ā§āύ āφāϏāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻ…āĻĒ⧇āĻ•ā§āώāĻž āĻ•āϰ⧇ āύāĻž āĻāĻŦāĻ‚ āϕ⧋āĻĄā§‡āϰ āĻĒāϰāĻŦāĻ°ā§āϤ⧀ āϞāĻžāχāύāϗ⧁āϞ⧋ āĻāĻ•ā§āϏāĻŋāĻ•āĻŋāωāϟ āĻ•āϰāϤ⧇ āĻĨāĻžāϕ⧇āĨ¤

 

⧍āĨ¤ āφāϗ⧇āχ āĻŦāϞ⧇āĻ›āĻŋāϞāĻžāĻŽ main() āĻĢāĻžāĻ‚āĻļāύ āϤāĻžāϰ āύāĻŋāϜāĻ¸ā§āĻŦ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻ āϚāϞ⧇āĨ¤ āĻāĻ–āύ āĻ…āĻ¨ā§āϝ āϕ⧋āύ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āϚāĻžāϞāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ āĻŽā§‡āχāύ āĻ—ā§‹-āϰ⧁āϟāĻŋāύāϟāĻŋ  āĻ…āĻŦāĻļā§āϝāχ āϚāϞāĻŽāĻžāύ āĻšāϤ⧇ āĻšāĻŦ⧇āĨ¤ āϝāĻĻāĻŋ āĻŽā§‡āχāύ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻŦāĻ¨ā§āϧ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ āϤāĻžāĻšāϞ⧇ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāϟāĻŋ āĻŦāĻ¨ā§āϧ āĻšāϝāĻŧ⧇ āϝāĻžāĻŦ⧇ āĻāĻŦāĻ‚ āĻ…āĻ¨ā§āϝ āϕ⧋āύ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āφāϰ āϚāϞāĻŦ⧇ āύāĻžāĨ¤Â 

āĻāχ āĻāĻ•āχ āĻ•āĻžāϜāϟāĻžāχ āφāĻŽāĻžāĻĻ⧇āϰ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽā§‡āϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āĻšā§Ÿā§‡āϛ⧇, āϝāĻžāϰ āĻ•āĻžāϰāϪ⧇ āφāĻŽāĻžāĻĻ⧇āϰ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖāĻ­āĻžāĻŦ⧇ āĻāĻ•ā§āϏāĻŋāĻ•āĻŋāωāϟ āĻšā§ŸāύāĻŋāĨ¤Â 

āĻāĻŦāĻžāϰ āĻāχ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāĻž āϝāĻžāĻ•āĨ¤ āύāĻŋāĻšā§‡āϰ āωāĻĻāĻžāĻšāϰāĻŖāϟāĻž āĻ–ā§‡ā§ŸāĻžāϞ āĻ•āϰāĻŋ – 

				
					  package main

   import ( 
       "fmt"
       "time"
   )

   func hello() { 
       fmt.Println("Hello world Goroutine")
   }
   func main() { 
       go hello()
       time.Sleep(1 * time.Second)
       fmt.Println("main function")
   }

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

				
			

āĻāĻ–āĻžāύ⧇ āφāĻŽāϰāĻž hello() āĻĢāĻžāĻ‚āĻļāύāϕ⧇ main() āĻĢāĻžāĻ‚āĻļāύ⧇āϰ āϭ⧇āϤāϰ āĻĨ⧇āϕ⧇ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ⧇ āĻĒāĻžāĻ āĻŋā§Ÿā§‡āĻ›āĻŋāĨ¤ āĻāĻ–āύ hello() āĻāϰ āϜāĻ¨ā§āϝ main() āĻĢāĻžāĻ‚āĻļāύ āĻ…āĻĒ⧇āĻ•ā§āώāĻž āύāĻž āĻ•āϰ⧇ āĻĒāϰ⧇āϰ āϞāĻžāχāύ⧇ āϚāϞ⧇ āϝāĻžāĻŦ⧇āĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĒāϰ⧇āϰ āϞāĻžāχāύ⧇ time.Sleep() āϕ⧇ āĻ•āϞ āĻ•āϰ⧇āĻ›āĻŋ āĻāĻŦāĻ‚ āϤāĻžāϕ⧇ āĻāĻ• āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻ…āĻĒ⧇āĻ•ā§āώāĻž āĻ•āϰāϤ⧇ āĻŦāϞ⧇āĻ›āĻŋāĨ¤ āĻāχ āĻ…āĻĒ⧇āĻ•ā§āώāĻžāĻ•āĻžāϞ⧀āύ āϏāĻŽā§Ÿā§‡āχ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻāϰ āĻĢāĻžāĻ‚āĻļāύāϟāĻŋ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖāĻ­āĻžāĻŦ⧇ āĻāĻ•ā§āϏāĻŋāĻ•āĻŋāωāϟ āĻšā§Ÿā§‡ āϝāĻžāĻŦ⧇ āĻāĻŦāĻ‚ āĻ•āύāϏ⧋āϞ⧇ “Hello word Goroutine” āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻ•āϰāĻŦ⧇āĨ¤ āĻāχ āĻāĻ• āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻ…āϤāĻŋāĻ•ā§āϰāĻžāĻ¨ā§āϤ āĻšāϞ⧇ āĻĒāϰ⧇āϰ āϕ⧋āĻĄ āϗ⧁āϞ⧋ āĻāĻ•ā§āϏāĻŋāĻ•āĻŋāωāϟ āĻšāĻ“ā§ŸāĻž āĻļ⧁āϰ⧁ āĻ•āϰāĻŦ⧇, āĻ…āĻ°ā§āĻĨāĻžā§Ž “main function” āĻŽā§‡āϏ⧇āϜāϟāĻŋ āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻšā§Ÿā§‡ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽ āĻļ⧇āώ āĻšāĻŦ⧇āĨ¤

[ā§Ē.ā§§.ā§Š]  āĻŽāĻžāĻ˛ā§āϟāĻŋāĻĒāϞ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ (Multiple Goroutine)  

āφāϗ⧇āχ āĻŦāϞāĻž āĻšā§Ÿā§‡āϛ⧇ āĻāĻ•āϟāĻž āϏāĻŋāĻ™ā§āϗ⧇āϞ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ⧇ āĻāĻ•āĻžāϧāĻŋāĻ• āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āύāĻŋāĻšā§‡āϰ āωāĻĻāĻžāĻšāϰāϪ⧇āϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ āĻŽāĻžāĻ˛ā§āϟāĻŋāĻĒāϞ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻŦ⧁āĻāĻžāϰ āĻšā§‡āĻˇā§āϟāĻž āĻ•āϰāĻŋ –

				
					 package main

   import ( 
       "fmt"
       "time"
   )

   func numbers() { 
       for i := 1; i <= 5; i++ {
           time.Sleep(250 * time.Millisecond)
           fmt.Printf("%d ", i)
       }
   }
   
   func alphabets() { 
       for i := 'a'; i <= 'e'; i++ {
           time.Sleep(400 * time.Millisecond)
           fmt.Printf("%c ", i)
       }
   }
   
   func main() { 
       go numbers()
       go alphabets()
       time.Sleep(3000 * time.Millisecond)
       fmt.Println("main terminated")
   }

   //Output : 1 a 2 3 b 4 c 5 d e main terminated

				
			

 āωāĻĒāϰ⧇āϰ āωāĻĻāĻžāĻšāϰāϪ⧇, āĻĻ⧁āχāϟāĻŋ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ numbers() āĻāĻŦāĻ‚ alphabets() āĻ•āύāĻ•āĻžāϰ⧇āĻ¨ā§āϟāϞāĻŋ āϚāϞāϤ⧇āϛ⧇āĨ¤ numbers āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻļ⧁āϰ⧁āϤ⧇ 250 āĻŽāĻŋāϞāĻŋāϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻ¸ā§āϞ⧀āĻĒ⧇āϰ āĻĒāϰ 1 āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻ•āϰāĻŦ⧇, āĻāϰāĻĒāϰ āφāϰāĻ“ 250 āĻŽāĻŋāϞāĻŋāϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻĒāϰ⧇ 2 āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻ•āϰāĻŦ⧇, āĻāĻ­āĻžāĻŦ⧇ 5 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻ•āϰāϤ⧇ āĻĨāĻžāĻ•āĻŦ⧇āĨ¤ āϏ⧇āχāĻŽ alphabets() 400 āĻŽāĻŋāϞāĻŋāϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻĒāϰāĻĒāϰ a āĻĨ⧇āϕ⧇ e  āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻ•āϰāϤ⧇ āĻĨāĻžāĻ•āĻŦ⧇āĨ¤ āϤāĻžāϰāĻĒāϰ 3000 āĻŽāĻŋāϞāĻŋāϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻĒāϰ “main terminated” āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻšāĻŦ⧇ āĻāĻŦāĻ‚ main() āĻĢāĻžāĻ‚āĻļāύ āĻŦāĻ¨ā§āϧ āĻšā§Ÿā§‡ āϝāĻžāĻŦ⧇āĨ¤

 

āφāϏāϞ⧇ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāϟāĻŋ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰāϛ⧇ āύāĻŋāĻšā§‡āϰ āĻĄāĻžā§ŸāĻžāĻ—ā§āϰāĻžāĻŽā§‡āϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ āĻŦ⧁āĻāĻžāϰ āĻšā§‡āĻˇā§āϟāĻž āĻ•āϰāĻŋ :

4.1.3 image

āĻ›āĻŦāĻŋāϟāĻŋāϰ āĻĒā§āϰāĻĨāĻŽ āĻ…āĻ‚āĻļ⧇āϰ āύ⧀āϞ āĻ•āĻžāϞāĻžāϰ āĻĻā§āĻŦāĻžāϰāĻž  numbers āĻ—ā§‹-āϰ⧁āϟāĻŋāύ , āĻĻā§āĻŦāĻŋāĻ¤ā§€ā§Ÿ āĻ…āĻ‚āĻļ⧇āϰ āϞāĻžāϞ āĻ•āĻžāϞāĻžāϰ āĻĻā§āĻŦāĻžāϰāĻž alphabets āĻ—ā§‹-āϰ⧁āϟāĻŋāύ  , āϤ⧃āĻ¤ā§€ā§Ÿ āĻ…āĻ‚āĻļ⧇āϰ āϏāĻŦ⧁āϜ āĻ•āĻžāϞāĻžāϰ āĻĻā§āĻŦāĻžāϰāĻž main āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻāĻŦāĻ‚ āϏāĻ°ā§āĻŦāĻļ⧇āώ āĻ•āĻžāϞ⧋ āĻ•āĻžāϞāĻžāϰ āĻĻā§āĻŦāĻžāϰāĻž āĻ…āωāϟāĻĒ⧁āϟ āĻĒā§āϰāĻ•āĻžāĻļ āĻ•āϰāĻž āĻšā§Ÿā§‡āϛ⧇āĨ¤ āφāĻļāĻž āĻ•āϰāĻž āϝāĻžā§ŸÂ  āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āφāĻŽāϰāĻž āĻŽā§‹āϟāĻžāĻŽā§āϟāĻŋ āĻŦ⧁āĻāϤ⧇ āĻĒ⧇āϰ⧇āĻ›āĻŋāĨ¤

[ā§Ē.ā§§.ā§Ē] āĻ•ā§āϞ⧋āϜāĻŋāĻ‚ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ(Closing Goroutine)

āĻ—ā§‹-āϰ⧁āϟāĻŋāύ⧇āϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻļ⧇āώ⧇ āϤāĻž āϏāĻ āĻŋāĻ•āĻ­āĻžāĻŦ⧇ āĻŦāĻ¨ā§āϧ āĻ•āϰāĻžāϟāĻž āϜāϰ⧁āϰāĻŋāĨ¤ āĻāχ āĻĒāĻ°ā§āϝāĻžā§Ÿā§‡ āφāĻŽāϰāĻž āϏāĻ āĻŋāĻ• āĻĒāĻĻā§āϧāϤāĻŋāϤ⧇ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻŦāĻ¨ā§āϧ āĻ•āϰāĻžāϰ āϧāĻžāĻĒāϗ⧁āϞ⧋āϰ āϏāĻžāĻĨ⧇ āĻĒāϰāĻŋāϚāĻŋāϤ āĻšāĻŦā§‹ – 

  • āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻŦāĻ¨ā§āϧ āĻ•āϰāĻžāϰ āϏāĻŦāĻĨ⧇āϕ⧇ āϏāĻšāϜ āωāĻĒāĻžā§Ÿ āĻšāϞ⧋ āϏāĻŋāĻ—āύāĻžāϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤ āĻāχ āĻĒāĻĻā§āϧāϤāĻŋāϤ⧇ āĻšā§āϝāĻžāύ⧇āϞ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻāĻ•āϟāĻŋ āϏāĻŋāĻ—āĻ¨ā§āϝāĻžāϞ āωāĻ•ā§āϤ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ⧇ āĻĒāĻžāĻ āĻžāύ⧋ āĻšā§Ÿ āĻāĻŦāĻ‚ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ āĻ“āχ āĻšā§āϝāĻžāύ⧇āϞ⧇ āĻ•āĻŋāϛ⧁ āϰāĻŋāϏāĻŋāϭ⧇āϰ āĻ…āĻĒ⧇āĻ•ā§āώāĻžā§Ÿ āĻĨāĻžāϕ⧇, āϝāĻž āĻĒā§‡ā§Ÿā§‡ āϗ⧇āϞ⧇ āύāĻŋāĻœā§‡ āĻĨ⧇āϕ⧇ āĻŦāĻ¨ā§āϧ āĻšā§Ÿā§‡ āϝāĻžā§ŸāĨ¤Â 
  • āĻĒā§āϰāĻĨāĻŽā§‡ āĻāĻ•āϟāĻŋ āĻšā§āϝāĻžāύ⧇āϞ āϤ⧈āϰāĻŋ āĻ•āϰ⧇ āύ⧇āĻŦā§‹ āϝāĻžāϰ āĻĻā§āĻŦāĻžāϰāĻž āφāĻŽāϰāĻž āϏāĻŋāĻ—āύāĻžāϞāϟāĻŋ āĻĒāĻžāĻ āĻžāĻŦā§‹ – 
				
					   cancel := make(chan struct{})
				
			
  •  āĻšā§āϝāĻžāύ⧇āϞāϟāĻŋ āĻāĻ•āϟāĻŋ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ⧇āϰ āĻĒā§āϝāĻžāϰāĻžāĻŽāĻŋāϟāĻžāϰ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻžāϏ āĻ•āϰāĻŋ – 
				
					   go worker(cancel)
				
			
  • āĻĢāĻžāĻ‚āĻļāύāϟāĻŋ – 

				
					 func worker(cancel <-chan struct{}) {
       fmt.Println("Worker started")
       defer fmt.Println("Worker stopped")
       for {
           select {
           case <-cancel:
               fmt.Println("Worker cancelled")
               return
           default:
               // Do some work here
               time.Sleep(time.Second)
               fmt.Println("Working...")
           }
       }
   }

				
			
  • āĻāĻŦāĻžāϰ⧇ cancel āĻšā§āϝāĻžāύ⧇āϞ⧇ āĻ•ā§āϞ⧋āϜāĻŋāĻ‚ āϏāĻŋāĻ—āύāĻžāϞ āĻĒāĻžāĻ āĻŋā§Ÿā§‡ āĻ—ā§‹-āϰ⧁āϟāĻŋāύāϟāĻŋ āĻŦāĻ¨ā§āϧ āĻšāĻŦāĻžāϰ āϜāĻ¨ā§āϝ āĻ…āĻĒ⧇āĻ•ā§āώāĻž āĻ•āϰāĻŦ – 
				
					time.Sleep(5 * time.Second)
   fmt.Println("Canceling worker")
   close(cancel)


   time.Sleep(2 * time.Second)
   fmt.Println("Main goroutine stopped")
				
			
  •  āĻ—ā§‹-āϰ⧁āϟāĻŋāύāϟāĻŋ āĻŦāĻ¨ā§āϧ āĻšā§Ÿā§‡ āϗ⧇āϞ⧇ āĻāϰāĻĒāϰ main() āĻĢāĻžāĻ‚āĻļāύ⧇āϰ āĻ•āĻžāϜ āĻļ⧇āώ⧇ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāϟāĻŋāϰ āĻ•āĻžāϜ āĻļ⧇āώ āĻšāĻŦ⧇āĨ¤ āϤāĻžāĻšāϞ⧇ āĻĒ⧁āϰ⧋ āϕ⧋āĻĄāϟāĻŋ āĻĻāĻžāρ⧜āĻžāϞ⧋ – 
				
					 package main

   import (
       "fmt"
       "time"
   )

   func worker(cancel <-chan struct{}) {
       fmt.Println("Worker started")
       defer fmt.Println("Worker stopped")
       for {
           select {
           case <-cancel:
               fmt.Println("Worker canceled")
               return
           default:
               // Do some work here
               time.Sleep(time.Second)
               fmt.Println("Working...")
           }
       }
   }


   func main() {
       cancel := make(chan struct{})
       go worker(cancel)
       time.Sleep(5 * time.Second)
       fmt.Println("Canceling worker")
       close(cancel)
       time.Sleep(2 * time.Second)
       fmt.Println("Main goroutine stopped")
   }

				
			
  • time.Sleep() āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āωāĻĻā§āĻĻ⧇āĻļā§āϝ āĻšāϞ⧋ āĻ—ā§‹-āϰ⧁āϟāĻŋāύ⧇āϰ āĻ•āĻžāϜ āĻ āĻŋāĻ•āĻŽāϤ⧋ āĻ•āϰāϤ⧇ āĻĻā§‡ā§ŸāĻžāĨ¤

āφāωāϟāĻĒ⧁āϟ – 

				
					Worker started
   Working...
   Working...
   Working...
   Working...
   Canceling worker
   Working...
   Worker canceled
   Worker stopped
   Main goroutine stopped