Golang l&agrave; một ng&ocirc;n ngữ lập tr&igrave;nh m&atilde; nguồn mở bao gồm nhiều t&iacute;nh năng như thư viện chuẩn, quản l&yacute; g&oacute;i, nhập kiểu tĩnh, hỗ trợ kiểm thử v&agrave; nền tảng độc lập . Golang l&agrave; một trong những ng&ocirc;n ngữ kh&aacute; được ưa chuộng gần đ&acirc;y v&agrave; c&oacute; nhu cầu sử dụng cao trong lập tr&igrave;nh. Kh&oacute;a học n&agrave;y TEK4.VN sẽ cung cấp c&aacute;c kh&aacute;i niệm cơ bản v&agrave; n&acirc;ng cao về Golang, v&iacute; dụ xử l&yacute; ngoại lệ, mạng v&agrave; tạo mẫu. Trong kh&oacute;a học n&agrave;y, bạn cũng sẽ học c&aacute;c kh&aacute;i niệm cốt l&otilde;i về t&iacute;nh đồng thời. Bạn cũng sẽ được cung cấp c&aacute;c c&acirc;u hỏi v&agrave; b&agrave;i tập gi&uacute;p luyện tập kỹ năng tư duy phản biện v&agrave; giải quyết vấn đề sử dụng Golang. Sau khi ho&agrave;n th&agrave;nh kh&oacute;a học, bạn c&oacute; thể sử dụng Golang để viết c&aacute;c ứng dụng hiệu quả v&agrave; thực tế sử dụng t&iacute;nh đồng thời.
<h3 style="text-align: justify;">Mục ti&ecirc;u</h3>
<ul style="text-align: justify;">
<li style="font-weight: 400;" aria-level="1">Học c&aacute;c kh&aacute;i niệm cơ bản của Golang</li>
<li style="font-weight: 400;" aria-level="1">Học về t&iacute;nh đồng thời v&agrave; c&aacute;c khối kiến thức x&acirc;y dựng li&ecirc;n quan đến t&iacute;nh đồng thời</li>
<li style="font-weight: 400;" aria-level="1">Học c&aacute;ch x&acirc;y dựng một ứng dụng web ho&agrave;n chỉnh bằng Golang</li>
</ul>

Golang từ cơ bản đến nâng cao

<h2 style="text-align: justify;">Chuỗi đồng bộ goroutine</h2>
Chương tr&igrave;nh sau đ&acirc;y cho thấy việc khởi tạo một lượng lớn goroutine rất đơn giản. 
<div class="code-editor__wrapped code-editor__edit__wrapped" data-id="26f26b66-679a-4807-af2c-c16577ed6213">
<table class="code-editor__table" data-id="b3a850aa-ad93-4c0a-b477-02c24607f141">
<tbody>
<tr class="code-editor__edit__row__first">
<td colspan="2">RUN_CODE (*** ph&acirc;n biệt ***)</td>
</tr>
<tr>
<td>GoLang</td>
<td>
<pre class="language-go" data-content="package" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>package main
import (
"flag"
"fmt"
)

var ngoroutine = flag.Int("n", 100000, "how many goroutines")

func f(left, right chan int) { left &lt;- 1+&lt;-right }

func main() {
 flag.Parse()
 leftmost := make(chan int)
 var left, right chan int = nil, leftmost
 for i := 0; i &lt; *ngoroutine; i++ {
 left, right = right, make(chan int)
 go f(left, right)
 }
 right &lt;- 0 // start the chaining
 x := &lt;-leftmost // wait for completion
 fmt.Println(x) // 100000, approx. 1.5 s
}</code></pre>
</td>
</tr>
</tbody>
</table>
</div>
Trong chương tr&igrave;nh n&agrave;y, bạn c&oacute; thể chỉ định số goroutine t&ugrave;y &yacute; tại d&ograve;ng lệnh. N&oacute; được lưu v&agrave;o flag <code>ngoroutine</code> (d&ograve;ng 7) khi c&aacute;c flag được ph&acirc;n t&iacute;ch c&uacute; ph&aacute;p (d&ograve;ng 12). 
Sau đ&oacute;, tại d&ograve;ng 14, ch&uacute;ng ta định nghĩa hai k&ecirc;nh số nguy&ecirc;n <code>left</code> v&agrave; <code>right</code> v&agrave; khởi tạo ch&uacute;ng. 
Trong v&ograve;ng lặp for (bắt đầu từ d&ograve;ng 15) với số y&ecirc;u cầu tối đa bằng số lần lặp. Đầu ti&ecirc;n ch&uacute;ng ta chuyển đổi gi&aacute; trị của k&ecirc;nh phải sang k&ecirc;nh tr&aacute;i tại d&ograve;ng 16. 
Sau đ&oacute;, ch&uacute;ng ta gọi h&agrave;m <code>f</code>, với cả hai k&ecirc;nh dưới dạng goroutine tại d&ograve;ng 17. 
H&agrave;m <code>f()</code> được định nghĩa tại d&ograve;ng 9, lấy một gi&aacute; trị từ <code>right</code>, tăng gi&aacute; trị v&agrave; đặt n&oacute; v&agrave;o <code>left</code>. 
D&ograve;ng 19 bắt đầu chuỗi bằng c&aacute;ch đặt 0 trong k&ecirc;nh <code>right</code>. 
D&ograve;ng 20 đợi cho đến khi phần tử cuối c&ugrave;ng c&oacute; thể được lấy ra từ k&ecirc;nh <code>leftmost</code>.
Việc nối chuỗi diễn ra trong v&ograve;ng lặp for trong <code>main</code>. Sau v&ograve;ng lặp, 0 được ch&egrave;n v&agrave;o k&ecirc;nh b&ecirc;n phải nhất, 100000 goroutine được thực thi v&agrave; kết quả (l&agrave; 100000) được in ra trong thời gian &iacute;t hơn 1,5 gi&acirc;y. Chương tr&igrave;nh cũng cho thấy số lượng goroutine c&oacute; thể được chỉ định tại d&ograve;ng lệnh v&agrave; được ph&acirc;n t&iacute;ch bằng <code>flag.Int</code>, v&iacute; dụ như -n=7000 sẽ tạo ra 7000 goroutine.
<h2 style="text-align: justify;">T&iacute;nh to&aacute;n song song tr&ecirc;n nhiều l&otilde;i&nbsp;</h2>
Giả sử ch&uacute;ng ta c&oacute; số l&otilde;i CPU l&agrave; <code>NCPU</code>:
<pre class="language-go" data-content="const%20NCPU%20%3D%204%20%2F%2F%20e.g.%204%20for%20a%20quadcore%20processor" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>const NCPU = 4 // e.g. 4 for a quadcore processor</code></pre>
Ngo&agrave;i ra, ch&uacute;ng ta muốn chia một t&iacute;nh to&aacute;n th&agrave;nh <code>NCPU</code> phần, mỗi phần chạy song song với những phần kh&aacute;c. Điều n&agrave;y c&oacute; thể được thực hiện (bỏ qua c&aacute;c th&ocirc;ng số cụ thể) như sau:
<pre class="language-go" data-content="func%20DoAll()%20%7B%0A%C2%A0%C2%A0sem%20%3A%3D%20make(chan%20int%2C%20NCPU)%20%2F%2F%20Buffering%20optional%20but%20sensible.%0A%C2%A0%C2%A0for%20i%20%3A%3D%200%3B%20i%20%3C%20NCPU%3B%20i%2B%2B%20%7B%0A%C2%A0%C2%A0%C2%A0%C2%A0go%20DoPart(sem)%0A%C2%A0%C2%A0%7D%0A%0A%C2%A0%C2%A0%2F%2F%20Drain%20the%20channel%20sem%2C%20waiting%20for%20NCPU%20tasks%20to%20complete%0A%C2%A0%C2%A0for%20i%20%3A%3D%200%3B%20i%20%3C%20NCPU%3B%20i%2B%2B%20%7B%0A%C2%A0%C2%A0%C2%A0%C2%A0%3C-sem%20%2F%2F%20wait%20for%20one%20task%20to%20complete%0A%C2%A0%C2%A0%7D%0A%0A%C2%A0%C2%A0%2F%2F%20All%20done.%0A%7D%0A%0Afunc%20DoPart(sem%20chan%20int)%20%7B%0A%C2%A0%C2%A0%2F%2F%20do%20the%20part%20of%20the%20computation%0A%C2%A0%C2%A0sem%20%3C-%201%20%2F%2F%20signal%20that%20this%20piece%20is%20done%0A%7D%0A%0Afunc%20main()%20%7B%0A%C2%A0%C2%A0runtime.GOMAXPROCS%20%3D%20NCPU%0A%C2%A0%C2%A0DoAll()%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>func DoAll() {
 sem := make(chan int, NCPU) // Buffering optional but sensible.
 for i := 0; i &lt; NCPU; i++ {
 go DoPart(sem)
 }

 // Drain the channel sem, waiting for NCPU tasks to complete
 for i := 0; i &lt; NCPU; i++ {
 &lt;-sem // wait for one task to complete
 }

 // All done.
}

func DoPart(sem chan int) {
 // do the part of the computation
 sem &lt;- 1 // signal that this piece is done
}

func main() {
 runtime.GOMAXPROCS = NCPU
 DoAll()
}</code></pre>
<ul style="text-align: justify;">
<li style="font-weight: 400;" aria-level="1">H&agrave;m <code>DoAll()</code> tạo k&ecirc;nh <code>sem</code> để mỗi phần t&iacute;nh to&aacute;n song song sẽ th&ocirc;ng b&aacute;o cho k&ecirc;nh khi n&oacute; ho&agrave;n th&agrave;nh. Trong v&ograve;ng lặp for, <code>NCPU</code> goroutine được khởi chạy, mỗi goroutine thực hiện 1/NCPU phần của c&ocirc;ng việc tổng thể.</li>
<li style="font-weight: 400;" aria-level="1">Mỗi goroutine của <code>DoPart()</code> gửi th&ocirc;ng b&aacute;o ho&agrave;n th&agrave;nh tr&ecirc;n k&ecirc;nh sem.</li>
<li style="font-weight: 400;" aria-level="1">H&agrave;m <code>DoAll()</code> đợi trong một v&ograve;ng lặp for cho đến khi tất cả c&aacute;c goroutine <code>NCPU</code> đ&atilde; ho&agrave;n th&agrave;nh. K&ecirc;nh <code>sem</code> hoạt động như một semaphore. Chương tr&igrave;nh n&agrave;y minh họa một pattern semaphore điển h&igrave;nh.</li>
</ul>
Trong m&ocirc; h&igrave;nh runtime hiện tại, bạn phải thiết lập <code>GOMAXPROCS</code> th&agrave;nh <code>NCPU</code>.
<h2 style="text-align: justify;">T&iacute;nh to&aacute;n song song tr&ecirc;n một lượng lớn dữ liệu</h2>
Giả sử ch&uacute;ng ta phải xử l&yacute; một lượng lớn c&aacute;c mục dữ liệu độc lập với nhau, đi v&agrave;o th&ocirc;ng qua k&ecirc;nh đầu v&agrave;o v&agrave; khi ho&agrave;n tất xử l&yacute; th&igrave; được đưa qua k&ecirc;nh đầu ra, giống như một đường ống nh&agrave; m&aacute;y. Qu&aacute; tr&igrave;nh xử l&yacute; mỗi mục dữ liệu bao gồm c&aacute;c bước: Tiền xử l&yacute; / Bước A / Bước B /&hellip; / Hậu xử l&yacute;.
Một thuật to&aacute;n xếp h&agrave;ng tuần tự điển h&igrave;nh c&oacute; thể giải quyết vấn đề n&agrave;y, thực hiện theo thứ tự từng bước như sau:
<pre class="language-go" data-content="func%20SerialProcessData%20(in%20%3C-%20chan%20*Data%2C%20out%20chan%20%3C-%20*Data)%20%7B%0A%C2%A0%C2%A0for%20data%20%3A%3D%20range%20in%20%7B%0A%C2%A0%C2%A0%C2%A0%C2%A0tmpA%20%3A%3D%20PreprocessData(data)%0A%C2%A0%C2%A0%C2%A0%C2%A0tmpB%20%3A%3D%20ProcessStepA(tmpA)%0A%C2%A0%C2%A0%C2%A0%C2%A0tmpC%20%3A%3D%20ProcessStepB(tmpB)%0A%C2%A0%C2%A0%C2%A0%C2%A0out%20%3C-%20PostProcessData(tmpC)%0A%C2%A0%C2%A0%7D%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>func SerialProcessData (in &lt;- chan *Data, out chan &lt;- *Data) {
 for data := range in {
 tmpA := PreprocessData(data)
 tmpB := ProcessStepA(tmpA)
 tmpC := ProcessStepB(tmpB)
 out &lt;- PostProcessData(tmpC)
 }
}</code></pre>
Chỉ một bước được thực hiện tại một thời điểm v&agrave; mỗi mục được xử l&yacute; theo thứ tự. Việc xử l&yacute; mục thứ hai kh&ocirc;ng bắt đầu trước khi mục thứ nhất đ&atilde; được xử l&yacute; v&agrave; kết quả được đưa v&agrave;o k&ecirc;nh ra. Nếu thử suy ngẫm, bạn sẽ nhận thấy c&aacute;ch n&agrave;y rất l&atilde;ng ph&iacute; thời gian. Một c&aacute;ch hiệu quả hơn l&agrave; để mỗi bước xử l&yacute; độc lập với nhau như một goroutine. Mỗi bước nhận dữ liệu đầu v&agrave;o từ k&ecirc;nh đầu ra của bước trước đ&oacute;. Điều đ&oacute; gi&uacute;p tiết kiệm thời gian v&agrave; trong hầu hết thời gian, tất cả c&aacute;c bước đều bận thực hiện c&ocirc;ng việc của ch&uacute;ng:
<pre class="language-go" data-content="func%20ParallelProcessData%20(in%20%3C-chan%20*Data%2C%20out%20chan%20%3C-%20*Data)%20%7B%0A%C2%A0%C2%A0%2F%2F%20make%20channels%3A%0A%C2%A0%C2%A0preOut%20%3A%3D%20make(chan%20*Data%2C%20100)%0A%C2%A0%C2%A0stepAOut%20%3A%3D%20make(chan%20*Data%2C%20100)%0A%C2%A0%C2%A0stepBOut%20%3A%3D%20make(chan%20*Data%2C%20100)%0A%C2%A0%C2%A0stepCOut%20%3A%3D%20make(chan%20*Data%2C%20100)%0A%C2%A0%C2%A0%2F%2F%20start%20parallel%20computations%3A%0A%C2%A0%C2%A0go%20PreprocessData(in%2C%20preOut)%0A%C2%A0%C2%A0go%20ProcessStepA(preOut%2C%20stepAOut)%0A%C2%A0%C2%A0go%20ProcessStepB(stepAOut%2C%20stepBOut)%0A%C2%A0%C2%A0go%20ProcessStepC(stepBOut%2C%20stepCOut)%0A%C2%A0%C2%A0go%20PostProcessData(stepCOut%2C%20out)%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>func ParallelProcessData (in &lt;-chan *Data, out chan &lt;- *Data) {
 // make channels:
 preOut := make(chan *Data, 100)
 stepAOut := make(chan *Data, 100)
 stepBOut := make(chan *Data, 100)
 stepCOut := make(chan *Data, 100)
 // start parallel computations:
 go PreprocessData(in, preOut)
 go ProcessStepA(preOut, stepAOut)
 go ProcessStepB(stepAOut, stepBOut)
 go ProcessStepC(stepBOut, stepCOut)
 go PostProcessData(stepCOut, out)
}</code></pre>
Dung lượng bộ đệm của k&ecirc;nh c&oacute; thể được sử dụng để tối ưu h&oacute;a to&agrave;n bộ qu&aacute; tr&igrave;nh.

Tính toán tuần tự và tính toán song song