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

Giả sử ch&uacute;ng ta phải thực hiện một số t&aacute;c vụ; mỗi t&aacute;c vụ được thực hiện bởi một (quy tr&igrave;nh) worker. <code>Task</code> c&oacute; thể được định nghĩa dưới dạng struct (chi tiết cụ thể kh&ocirc;ng quan trọng ở đ&acirc;y):
<pre class="language-go" data-content="type%20Task%20struct%20%7B%0A%2F%2F%20some%20state%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>type Task struct {
// some state
}</code></pre>
<h2 style="text-align: justify;">Phương ph&aacute;p 1: sử dụng bộ nhớ chung để đồng bộ</h2>
Danh s&aacute;ch t&aacute;c vụ (Pool) l&agrave; bộ nhớ được chia sẻ. Để đồng bộ c&ocirc;ng việc v&agrave; tr&aacute;nh race conditions, ch&uacute;ng ta phải bảo vệ danh s&aacute;ch n&agrave;y bằng một kh&oacute;a <code>Mutex</code>:
<pre class="language-go" data-content="type%20Pool%20struct%20%7B%0AMu%20sync.Mutex%0ATasks%20%5B%5DTask%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>type Pool struct {
Mu sync.Mutex
Tasks []Task
}</code></pre>
<code>sync.Mutex</code> (đ&atilde; đề cập trong kh&oacute;a học) l&agrave; một kh&oacute;a loại trừ đối xứng. N&oacute; được sử dụng để bảo vệ đầu v&agrave;o của phần nhạy cảm trong chương tr&igrave;nh. Chỉ một goroutine (luồng) c&oacute; thể truy cập v&agrave;o phần đ&oacute; tại một thời điểm. Việc cho ph&eacute;p nhiều hơn một goroutine truy cập c&oacute; thể dẫn đến race-condition, tức l&agrave; struct <code>Pool</code> kh&ocirc;ng c&ograve;n được cập nhật đ&uacute;ng c&aacute;ch nữa.
Trong m&ocirc; h&igrave;nh truyền thống (&aacute;p dụng trong hầu hết c&aacute;c ng&ocirc;n ngữ lập tr&igrave;nh hướng đối tượng như C++, Java v&agrave; C#), quy tr&igrave;nh <code>Worker</code> c&oacute; thể được m&atilde; h&oacute;a như sau:
<pre class="language-go" data-content="func%20Worker(pool%20*Pool)%20%7B%0A%C2%A0%C2%A0for%20%7B%0A%C2%A0%C2%A0%C2%A0%C2%A0pool.Mu.Lock()%0A%C2%A0%C2%A0%C2%A0%C2%A0%2F%2F%20begin%20critical%20section%3A%0A%C2%A0%C2%A0%C2%A0%C2%A0task%20%3A%3D%20pool.Tasks%5B0%5D%20%2F%2F%20take%20the%20first%20task%0A%C2%A0%C2%A0%C2%A0%C2%A0pool.Tasks%20%3D%20pool.Tasks%5B1%3A%5D%20%2F%2F%20update%20the%20pool%20of%20tasks%0A%C2%A0%C2%A0%C2%A0%C2%A0%2F%2F%20end%20critical%20section%0A%C2%A0%C2%A0%C2%A0%C2%A0pool.Mu.Unlock()%0A%C2%A0%C2%A0%C2%A0%C2%A0process(task)%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 Worker(pool *Pool) {
 for {
 pool.Mu.Lock()
 // begin critical section:
 task := pool.Tasks[0] // take the first task
 pool.Tasks = pool.Tasks[1:] // update the pool of tasks
 // end critical section
 pool.Mu.Unlock()
 process(task)
 }
}</code></pre>
Nhiều quy tr&igrave;nh Worker c&oacute; thể chạy đồng thời. Ch&uacute;ng chắc chắn c&oacute; thể được khởi chạy dưới dạng goroutine. Worker kh&oacute;a danh s&aacute;ch t&aacute;c vụ, lấy ra t&aacute;c vụ đầu ti&ecirc;n từ danh s&aacute;ch, mở kh&oacute;a danh s&aacute;ch, sau đ&oacute; xử l&yacute; t&aacute;c vụ đ&oacute;. Kh&oacute;a đảm bảo chỉ một quy tr&igrave;nh Worker c&oacute; thể truy cập v&agrave;o danh s&aacute;ch tại một thời điểm. Một t&aacute;c vụ được giao cho một v&agrave; chỉ một quy tr&igrave;nh Worker. Nếu kh&ocirc;ng c&oacute; kh&oacute;a, việc xử l&yacute; của Worker c&oacute; thể bị gi&aacute;n đoạn ở c&aacute;c d&ograve;ng <code>task := pool.Tasks[0] v&agrave; pool.Tasks = pool.Tasks[1:]</code>, dẫn đến kết quả bất thường. Một số Worker kh&ocirc;ng c&oacute; t&aacute;c vụ để xử l&yacute; v&agrave; một v&agrave;i Worker kh&aacute;c nhận được nhiều t&aacute;c vụ. Cơ chế đồng bộ kh&oacute;a n&agrave;y hoạt động tốt cho một số quy tr&igrave;nh Worker. Tuy nhi&ecirc;n, nếu <code>Pool</code> rất lớn v&agrave; ch&uacute;ng ta chỉ định một số lượng lớn quy tr&igrave;nh l&agrave;m việc tr&ecirc;n n&oacute;, hiệu suất xử l&yacute; sẽ giảm đi do chi ph&iacute; của cơ chế lock-unlock. Đ&acirc;y l&agrave; điểm nghẽn l&agrave;m giảm hiệu suất đ&aacute;ng kể khi số lượng c&aacute;c quy tr&igrave;nh tăng đột biến ở ngưỡng nhất định.
<h2 style="text-align: justify;">Phương ph&aacute;p 2: Sử dụng k&ecirc;nh</h2>
Với m&ocirc; h&igrave;nh n&agrave;y, c&aacute;c k&ecirc;nh của <code>Task</code> được sử dụng để đồng bộ h&oacute;a. K&ecirc;nh pending nhận c&aacute;c t&aacute;c vụ được y&ecirc;u cầu v&agrave; k&ecirc;nh done nhận c&aacute;c t&aacute;c vụ đ&atilde; thực hiện (với kết quả tương ứng). Quy tr&igrave;nh worker được khởi chạy dưới dạng goroutine; số lượng N n&ecirc;n được điều chỉnh cho ph&ugrave; hợp với số lượng t&aacute;c vụ. Goroutine main, thực hiện chức năng của <code>Master</code>, c&oacute; thể được lập tr&igrave;nh như sau:
<pre class="language-go" data-content="func%20main()%20%7B%0A%C2%A0%C2%A0pending%2C%20done%20%3A%3D%20make(chan%20*Task)%2C%20make(chan%20*Task)%0A%C2%A0%C2%A0go%20sendWork(pending)%20%2F%2F%20put%20tasks%20to%20do%20on%20the%20channel%0A%C2%A0%C2%A0for%20i%20%3A%3D%200%3B%20i%20%3C%20N%3B%20i%2B%2B%20%7B%20%2F%2F%20start%20N%20goroutines%20to%20do%20work%0A%C2%A0%C2%A0%C2%A0%C2%A0go%20Worker(pending%2C%20done)%0A%C2%A0%C2%A0%7D%0A%C2%A0%C2%A0consumeWork(done)%20%2F%2F%20continue%20with%20the%20processed%20tasks%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>func main() {
 pending, done := make(chan *Task), make(chan *Task)
 go sendWork(pending) // put tasks to do on the channel
 for i := 0; i &lt; N; i++ { // start N goroutines to do work
 go Worker(pending, done)
 }
 consumeWork(done) // continue with the processed tasks
}</code></pre>
Quy tr&igrave;nh worker rất đơn giản, ta chỉ cần lấy một t&aacute;c vụ từ k&ecirc;nh pending, xử l&yacute; v&agrave; đưa t&aacute;c vụ đ&atilde; ho&agrave;n th&agrave;nh v&agrave;o k&ecirc;nh done:
<pre class="language-go" data-content="func%20main()%20%7B%0A%C2%A0%C2%A0pending%2C%20done%20%3A%3D%20make(chan%20*Task)%2C%20make(chan%20*Task)%0A%C2%A0%C2%A0go%20sendWork(pending)%20%2F%2F%20put%20tasks%20to%20do%20on%20the%20channel%0A%C2%A0%C2%A0for%20i%20%3A%3D%200%3B%20i%20%3C%20N%3B%20i%2B%2B%20%7B%20%2F%2F%20start%20N%20goroutines%20to%20do%20work%0A%C2%A0%C2%A0%C2%A0%C2%A0go%20Worker(pending%2C%20done)%0A%C2%A0%C2%A0%7D%0A%C2%A0%C2%A0consumeWork(done)%20%2F%2F%20continue%20with%20the%20processed%20tasks%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>func main() {
 pending, done := make(chan *Task), make(chan *Task)
 go sendWork(pending) // put tasks to do on the channel
 for i := 0; i &lt; N; i++ { // start N goroutines to do work
 go Worker(pending, done)
 }
 consumeWork(done) // continue with the processed tasks
}</code></pre>
Do kh&ocirc;ng sử dụng cơ chế kh&oacute;a; qu&aacute; tr&igrave;nh lấy một t&aacute;c vụ mới kh&ocirc;ng dẫn đến xung đột. Nếu số lượng t&aacute;c vụ tăng, số lượng workers c&oacute; thể tăng tương ứng v&agrave; hiệu suất sẽ kh&ocirc;ng giảm đ&aacute;ng kể như trong giải ph&aacute;p thứ nhất. Tất nhi&ecirc;n, chỉ c&oacute; một bản sao của k&ecirc;nh pending trong bộ nhớ. Tuy nhi&ecirc;n, kh&ocirc;ng c&oacute; xung đột xảy ra v&igrave; <code>Worker</code> đầu ti&ecirc;n ho&agrave;n th&agrave;nh t&aacute;c vụ chờ đầu ti&ecirc;n, n&oacute; sẽ phải xử l&yacute; t&aacute;c vụ đ&oacute; ho&agrave;n to&agrave;n, v&igrave; việc đọc v&agrave; gửi đến k&ecirc;nh đều l&agrave; c&aacute;c hoạt động nguy&ecirc;n tử. Tức l&agrave; ta kh&ocirc;ng thể dự đo&aacute;n t&aacute;c vụ n&agrave;o sẽ được thực hiện bởi quy tr&igrave;nh n&agrave;o v&agrave; ngược lại. Với số lượng workers tăng l&ecirc;n, chi ph&iacute; giao tiếp cũng tăng l&ecirc;n, tuy nhi&ecirc;n n&oacute; &iacute;t ảnh hưởng đến hiệu suất hệ thống.
Trong v&iacute; dụ đơn giản n&agrave;y, bạn c&oacute; thể kh&oacute; nh&igrave;n ra ưu điểm của m&ocirc; h&igrave;nh thứ hai, nhưng với c&aacute;c ứng dụng c&oacute; t&igrave;nh huống kh&oacute;a phức tạp th&igrave; rất kh&oacute; lập tr&igrave;nh v&agrave; thiết kế một c&aacute;ch hiệu quả. Ch&uacute;ng ta sẽ kh&ocirc;ng gặp nhiều sự phức tạp như n&agrave;y nếu &aacute;p dụng m&ocirc; h&igrave;nh thứ hai.
V&igrave; vậy, với giải ph&aacute;p n&agrave;y, hiệu suất l&agrave; một lợi thế đ&aacute;ng kể, tuy nhi&ecirc;n việc chương tr&igrave;nh trở n&ecirc;n r&otilde; r&agrave;ng v&agrave; gọn g&agrave;ng c&oacute; lẽ l&agrave; một lợi thế lớn hơn nhiều. Đ&acirc;y được coi l&agrave; một phương ph&aacute;p theo phong c&aacute;ch Go:
<h2 style="text-align: justify;">Sử dụng k&ecirc;nh v&agrave;o v&agrave; k&ecirc;nh ra thay v&igrave; kh&oacute;a</h2>
<pre class="language-go" data-content="func%20Worker(in%2C%20out%20chan%20*Task)%20%7B%0A%C2%A0%C2%A0for%20%7B%0A%C2%A0%C2%A0%C2%A0%C2%A0t%20%3A%3D%20%3C-in%0A%C2%A0%C2%A0%C2%A0%C2%A0process(t)%0A%C2%A0%C2%A0%C2%A0%C2%A0out%20%3C-%20t%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 Worker(in, out chan *Task) {
 for {
 t := &lt;-in
 process(t)
 out &lt;- t
 }
}</code></pre>
Đối với bất kỳ vấn đề n&agrave;o c&oacute; thể được m&ocirc; h&igrave;nh h&oacute;a dưới dạng m&ocirc; h&igrave;nh Master-Worker, một giải ph&aacute;p tương tự sử dụng <code>Workers</code> l&agrave; c&aacute;c goroutine giao tiếp th&ocirc;ng qua k&ecirc;nh v&agrave; <code>Master</code> đ&oacute;ng vai tr&ograve; l&agrave; điều phối. Nếu hệ thống ph&acirc;n t&aacute;n tr&ecirc;n nhiều m&aacute;y t&iacute;nh, một số m&aacute;y c&oacute; thể thực thi c&aacute;c goroutine <code>Worker</code> v&agrave; <code>Master</code> v&agrave; <code>Workers</code> c&oacute; thể giao tiếp với nhau th&ocirc;ng qua <code>netchan</code> hoặc <code>rpc</code>.
<h2 style="text-align: justify;">N&ecirc;n sử dụng "sync.Mutex" hay k&ecirc;nh?</h2>
Mặc d&ugrave; chương n&agrave;y nhấn mạnh v&agrave;o việc sử dụng k&ecirc;nh, v&igrave; điều n&agrave;y kh&aacute; mới mẻ trong c&aacute;c ng&ocirc;n ngữ hệ thống, nhưng n&oacute; kh&ocirc;ng c&oacute; nghĩa l&agrave; ta n&ecirc;n bỏ qua phương ph&aacute;p cổ điển với kh&oacute;a. Go hỗ trợ cả hai v&agrave; bạn c&oacute; thể lựa chọn t&ugrave;y thuộc v&agrave;o vấn đề cần giải quyết. H&atilde;y cố gắng x&acirc;y dựng một giải ph&aacute;p r&otilde; r&agrave;ng, đơn giản v&agrave; dễ đọc nhất v&agrave; trong hầu hết c&aacute;c trường hợp, điều n&agrave;y dẫn đến hiệu suất tối ưu. Đừng ngại sử dụng <code>Mutex</code> nếu n&oacute; ph&ugrave; hợp với trường hợp của bạn. Go cung cấp c&aacute;c c&ocirc;ng cụ để giải quyết vấn đề theo hướng hiệu quả nhất v&agrave; kh&ocirc;ng &eacute;p bạn phải sử dụng một phong c&aacute;ch duy nhất. Như vậy, quy tắc chung l&agrave;:
<h3 style="text-align: justify;">Sử dụng kh&oacute;a (mutex)</h3>
Sử dụng mutex khi:
<ul style="text-align: justify;">
<li style="font-weight: 400;" aria-level="1">Lưu trữ th&ocirc;ng tin v&agrave;o một cấu tr&uacute;c dữ liệu chung</li>
<li style="font-weight: 400;" aria-level="1">Giữ th&ocirc;ng tin trạng th&aacute;i, v&iacute; dụ như ngữ cảnh hoặc trạng th&aacute;i của ứng dụng đang chạy.</li>
</ul>
<h3 style="text-align: justify;">Sử dụng k&ecirc;nh</h3>
Sử dụng k&ecirc;nh khi:
<ul style="text-align: justify;">
<li style="font-weight: 400;" aria-level="1">Truyền tải kết quả kh&ocirc;ng đồng bộ</li>
<li style="font-weight: 400;" aria-level="1">Ph&acirc;n phối đơn vị c&ocirc;ng việc</li>
<li style="font-weight: 400;" aria-level="1">Chuyển quyền sở hữu của dữ liệu</li>
</ul>
Nếu bạn thấy quy tắc kh&oacute;a của bạn đang trở n&ecirc;n qu&aacute; phức tạp, h&atilde;y tự hỏi xem việc sử dụng k&ecirc;nh c&oacute; đơn giản h&oacute;a vấn đề hay kh&ocirc;ng.
V&igrave; vậy, khi thiết kế một c&aacute;ch để giao tiếp giữa c&aacute;c goroutine, cho d&ugrave; l&agrave; sử dụng bộ nhớ chung hay k&ecirc;nh, bạn cần xem x&eacute;t nhiều yếu tố để đạt được hiệu suất tốt nhất.&nbsp;

Tasks và Quy trình Worker