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

G&oacute;i <code>time</code> cung cấp một số t&iacute;nh năng th&uacute; vị khi sử dụng kết hợp với k&ecirc;nh. N&oacute; chứa struct <code>time.Ticker</code>, đ&acirc;y l&agrave; một đối tượng li&ecirc;n tục gửi gi&aacute; trị thời gian đến k&ecirc;nh C nằm trong đối tượng, trong một khoảng thời gian x&aacute;c định:
<pre class="language-go" data-content="type%20Ticker%20struct%20%7B%0A%C2%A0%C2%A0C%20%3C-chan%20Time%20%2F%2F%20the%20channel%20on%20which%20the%20ticks%20are%20delivered.%0A%C2%A0%C2%A0%2F%2F%20contains%20filtered%20or%20unexported%20fields%0A%C2%A0%C2%A0...%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>type Ticker struct {
 C &lt;-chan Time // the channel on which the ticks are delivered.
 // contains filtered or unexported fields
 ...
}</code></pre>
Trong qu&aacute; tr&igrave;nh thực thi c&aacute;c goroutine, <code>Ticker</code> c&oacute; thể hữu &iacute;ch khi ch&uacute;ng ta cần thực hiện một số c&ocirc;ng việc (ghi lại trạng th&aacute;i, in đầu ra, t&iacute;nh to&aacute;n, v.v.) định kỳ trong một khoảng thời gian x&aacute;c định. <code>Ticker</code> được dừng lại bằng c&aacute;ch sử dụng <code>Stop()</code> trong một c&acirc;u lệnh <code>defer</code>. Tất cả điều n&agrave;y c&oacute; thể được thực hiện một c&aacute;ch linh hoạt trong c&acirc;u lệnh <code>select</code>:
<pre class="language-go" data-content="ticker%20%3A%3D%20time.NewTicker(updateInterval)%0Adefer%20ticker.Stop()%0A...%0Aselect%20%7B%0A%C2%A0%C2%A0case%20u%3A%3D%20%3C-%20ch1%3A%0A%C2%A0%C2%A0%C2%A0%C2%A0...%0A%C2%A0%C2%A0case%20v%3A%3D%20%3C-%20ch2%3A%0A%C2%A0%C2%A0%C2%A0%C2%A0...%0A%C2%A0%C2%A0case%20%3C-%20ticker.C%3A%0A%0A%C2%A0%C2%A0%C2%A0logState(status)%20%2F%2F%20e.g.%20call%20some%20logging%20function%20logState%0A%0A%C2%A0%C2%A0default%3A%20%2F%2F%20no%20value%20ready%20to%20be%20received%0A%C2%A0%C2%A0%C2%A0%C2%A0...%0A%7D" data-language="c" data-ace-language="c_cpp" data-name-language="C" data-main-file="main.c"><code>ticker := time.NewTicker(updateInterval)
defer ticker.Stop()
...
select {
 case u:= &lt;- ch1:
 ...
 case v:= &lt;- ch2:
 ...
 case &lt;- ticker.C:

 logState(status) // e.g. call some logging function logState

 default: // no value ready to be received
 ...
}</code></pre>
H&agrave;m <code>time.Tick()</code> với chữ k&yacute; <code>func Tick(d Duration) &lt;-chan Time</code> rất hữu &iacute;ch khi bạn chỉ cần truy cập k&ecirc;nh trả về v&agrave; kh&ocirc;ng cần đ&oacute;ng n&oacute;. N&oacute; gửi thời gian tr&ecirc;n k&ecirc;nh trả về với chu kỳ <code>d</code>, theo đơn vị nanosecond. N&oacute; rất tiện lợi khi bạn phải giới hạn tỷ lệ xử l&yacute; mỗi đơn vị thời gian như trong đoạn code sau (h&agrave;m <code>client.Call()</code> l&agrave; một lệnh gọi RPC, chi tiết kh&ocirc;ng được đề cập th&ecirc;m ở đ&acirc;y):
<pre class="language-go" data-content="import%20%22time%22%0A%0Arate_per_sec%20%3A%3D%2010%0Avar%20dur%20Duration%20%3D%201e9%20%2F%20rate_per_sec%0AchRate%20%3A%3D%20time.Tick(dur)%20%2F%2F%20a%20tick%20every%201%2F10th%20of%20a%20second%0Afor%20req%20%3A%3D%20range%20requests%20%7B%0A%C2%A0%C2%A0%3C-%20chRate%20%2F%2F%20rate%20limit%20our%20Service.Method%20RPC%20calls%0A%C2%A0%C2%A0go%20client.Call(%22Service.Method%22%2C%20req%2C%20...)%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>import "time"

rate_per_sec := 10
var dur Duration = 1e9 / rate_per_sec
chRate := time.Tick(dur) // a tick every 1/10th of a second
for req := range requests {
 &lt;- chRate // rate limit our Service.Method RPC calls
 go client.Call("Service.Method", req, ...)
}</code></pre>
Kết quả l&agrave; c&aacute;c y&ecirc;u cầu mới chỉ được xử l&yacute; với tốc độ chỉ định, tức l&agrave; k&ecirc;nh <code>chRate</code> sẽ chặn c&aacute;c y&ecirc;u cầu với tốc độ cao hơn. Tốc độ mỗi gi&acirc;y c&oacute; thể tăng hoặc giảm theo tải v&agrave;/hoặc t&agrave;i nguy&ecirc;n của m&aacute;y.
Kiểu <code>tick</code> tr&ocirc;ng giống như kiểu <code>Ticker</code> (n&oacute; được tạo bằng <code>time.Tick(d Duration)</code>), nhưng n&oacute; chỉ gửi thời gian một lần, sau <code>Duration d</code>. Ngo&agrave;i ra ta cũng c&oacute; h&agrave;m <code>time.After(d)</code> với chữ k&yacute;: <code>func After(d Duration) &lt;-chan Time</code>. Sau <code>Duration d</code>, thời gian hiện tại được gửi tr&ecirc;n k&ecirc;nh trả về; điều n&agrave;y tương đương với <code>NewTimer(d).C</code> N&oacute; giống như <code>Tick()</code>, nhưng <code>After()</code> chỉ gửi thời gian một lần. Đoạn code sau l&agrave; một v&iacute; dụ minh họa cụ thể về mệnh đề <code>default</code> trong <code>select</code>:
Timer goroutines 
<div class="code-editor__wrapped code-editor__edit__wrapped" data-id="2bf05b00-124d-43f0-a287-7f2b4e4d1414">
<table class="code-editor__table" data-id="0d89bb68-8a9b-4a78-933a-bdbc300f52e8">
<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 (
"fmt"
"time"
)

func main() {
 tick := time.Tick(1e8)
 boom := time.After(5e8)
 for {
 select {
 case &lt;-tick:
 fmt.Println("tick.")
 case &lt;-boom:
 fmt.Println("BOOM!")
 return
 default:
 fmt.Println(" .")
 time.Sleep(5e7)
 }
 }
}</code></pre>
</td>
</tr>
</tbody>
</table>
</div>
Trong đoạn code tr&ecirc;n, h&atilde;y xem d&ograve;ng 8. <code>time.Tick</code> tạo ra một tick mỗi 1/8 gi&acirc;y, gửi thời gian hiện tại tr&ecirc;n k&ecirc;nh trả về. Ở d&ograve;ng 9, <code>time.Afte</code>r cũng tạo một k&ecirc;nh gửi thời gian hiện tại, nhưng chỉ gửi một lần sau 5/8 gi&acirc;y, trong đ&oacute; <code>tick</code> v&agrave; <code>boom</code> l&agrave; c&aacute;c k&ecirc;nh nhận.
Trong v&ograve;ng lặp v&ocirc; hạn bắt đầu từ d&ograve;ng 10, c&acirc;u lệnh <code>select</code> mặc định in một . v&agrave; sleep (ngủ) một l&uacute;c. Nếu c&oacute; gi&aacute; trị tr&ecirc;n k&ecirc;nh <code>tick</code> (d&ograve;ng 12), n&oacute; in ra tick. Khi c&oacute; gi&aacute; trị tr&ecirc;n k&ecirc;nh <code>boom</code> (d&ograve;ng 14), n&oacute; in ra boom v&agrave; trả về, dừng chương tr&igrave;nh.
<h2 style="text-align: justify;">Pattern timeout đơn giản</h2>
<h3 style="text-align: justify;">Dạng 1</h3>
Ch&uacute;ng ta muốn nhận dữ liệu từ k&ecirc;nh <code>ch</code>, nhưng chỉ muốn chờ tối đa 1 gi&acirc;y để gi&aacute; trị được gửi đến. Bắt đầu bằng c&aacute;ch tạo một k&ecirc;nh th&ocirc;ng b&aacute;o v&agrave; khởi chạy một goroutine lambda ngủ một khoảng thời gian trước khi gửi t&iacute;n hiệu tr&ecirc;n k&ecirc;nh:
<pre class="language-go" data-content="timeout%20%3A%3D%20make(chan%20bool%2C%201)%0Ago%20func()%20%7B%0A%C2%A0%C2%A0time.Sleep(1e9)%20%2F%2F%20one%20second%0A%C2%A0%C2%A0timeout%20%3C-%20true%0A%7D()" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>timeout := make(chan bool, 1)
go func() {
 time.Sleep(1e9) // one second
 timeout &lt;- true
}()</code></pre>
Sau đ&oacute;, sử dụng c&acirc;u lệnh <code>select</code> để nhận từ <code>ch</code> hoặc timeout: nếu kh&ocirc;ng c&oacute; g&igrave; được gửi đến <code>ch</code> trong 1 gi&acirc;y, case timeout được chọn v&agrave; việc đọc từ k&ecirc;nh <code>ch</code> bị bỏ qua.
<pre class="language-go" data-content="select%20%7B%0A%C2%A0%C2%A0case%20%3C-ch%3A%0A%C2%A0%C2%A0%2F%2F%20a%20read%20from%20ch%20has%20occurred%0A%C2%A0%C2%A0case%20%3C-timeout%3A%0A%C2%A0%C2%A0%2F%2F%20the%20read%20from%20ch%20has%20timed%20out%0A%C2%A0%C2%A0break%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>select {
 case &lt;-ch:
 // a read from ch has occurred
 case &lt;-timeout:
 // the read from ch has timed out
 break
}</code></pre>
<h3 style="text-align: justify;">Dạng 2 - bỏ c&aacute;c lệnh gọi đồng bộ</h3>
Ch&uacute;ng ta cũng c&oacute; thể sử dụng h&agrave;m <code>time.After ()</code> thay v&igrave; k&ecirc;nh timeout. H&agrave;m c&oacute; thể được sử dụng trong một c&acirc;u lệnh <code>select</code> để th&ocirc;ng b&aacute;o cho timeout hoặc dừng việc thực thi của goroutine. Khi trong đoạn code sau đ&acirc;y, <code>client.Call</code> kh&ocirc;ng trả về gi&aacute; trị cho k&ecirc;nh <code>ch</code> sau <code>timeoutNs ns</code>, case timeout được thực thi trong c&acirc;u lệnh <code>select</code>:
<pre class="language-go" data-content="ch%20%3A%3D%20make(chan%20error%2C%201)%0Ago%20func()%20%7B%20ch%20%3C-%20client.Call(%22Service.Method%22%2C%20args%2C%20%26reply)%20%7D%20()%0A%C2%A0%C2%A0select%20%7B%0A%C2%A0%C2%A0%C2%A0%C2%A0case%20resp%20%3A%3D%20%3C-ch%3A%0A%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%2F%2F%20use%20resp%20and%20reply%0A%C2%A0%C2%A0%C2%A0%C2%A0case%20%3C-time.After(timeoutNs)%3A%0A%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%2F%2F%20call%20timed%20out%0A%C2%A0%C2%A0%C2%A0break%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>ch := make(chan error, 1)
go func() { ch &lt;- client.Call("Service.Method", args, &amp;reply) } ()
 select {
 case resp := &lt;-ch:
 // use resp and reply
 case &lt;-time.After(timeoutNs):
 // call timed out
 break
}</code></pre>
[___NOTE_Việc đặt k&iacute;ch thước bộ đệm l&agrave; 1 l&agrave; cần thiết để tr&aacute;nh t&igrave;nh trạng deadlock hoặc v&agrave; đảm bảo thu gom r&aacute;c cho k&ecirc;nh timeout._NOTE___]
<h3 style="text-align: justify;">Dạng 3</h3>
Giả sử ch&uacute;ng ta c&oacute; một chương tr&igrave;nh đọc từ nhiều cơ sở dữ liệu sao lưu đồng thời. Chương tr&igrave;nh chỉ cần một trong c&aacute;c c&acirc;u trả lời v&agrave; n&oacute; sẽ nhận c&acirc;u trả lời đầu ti&ecirc;n được gửi đến. H&agrave;m <code>Query</code> nhận một slice của kết nối cơ sở dữ liệu v&agrave; một chuỗi truy vấn. N&oacute; truy vấn mỗi cơ sở dữ liệu song song v&agrave; trả về c&acirc;u trả lời đầu ti&ecirc;n nhận được:
<pre class="language-go" data-content="func%20Query(conns%20%5B%5DConn%2C%20query%20string)%20Result%20%7B%0A%C2%A0%C2%A0ch%20%3A%3D%20make(chan%20Result%2C%201)%0A%C2%A0%C2%A0for%20_%2C%20conn%20%3A%3D%20range%20conns%20%7B%0A%C2%A0%C2%A0%C2%A0%C2%A0go%20func(c%20Conn)%20%7B%0A%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0select%20%7B%0A%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0case%20ch%20%3C-%20c.DoQuery(query)%3A%0A%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0default%3A%0A%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%7D%0A%C2%A0%C2%A0%C2%A0%C2%A0%7D(conn)%0A%C2%A0%C2%A0%7D%0Areturn%20%3C-%20ch%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>func Query(conns []Conn, query string) Result {
 ch := make(chan Result, 1)
 for _, conn := range conns {
 go func(c Conn) {
 select {
 case ch &lt;- c.DoQuery(query):
 default:
 }
 }(conn)
 }
return &lt;- ch
}</code></pre>
Ở đ&acirc;y, k&ecirc;nh kết quả <code>ch</code> phải được lưu trữ v&agrave;o bộ đệm; điều n&agrave;y đảm bảo rằng lần gửi đầu ti&ecirc;n c&oacute; một nơi để đặt gi&aacute; trị v&agrave; đảm bảo rằng n&oacute; sẽ lu&ocirc;n th&agrave;nh c&ocirc;ng. Do đ&oacute;, gi&aacute; trị đầu ti&ecirc;n đến sẽ được lấy ra bất kể thứ tự thực thi.
<h2 style="text-align: justify;">Lưu trữ dữ liệu trong ứng dụng</h2>
C&aacute;c ứng dụng l&agrave;m việc với dữ liệu đến từ cơ sở dữ liệu (hoặc kho lưu trữ dữ liệu n&oacute;i chung) thường lưu trữ dữ liệu đ&oacute; trong bộ nhớ cache v&igrave; việc truy xuất một gi&aacute; trị từ cơ sở dữ liệu l&agrave; một hoạt động tốn k&eacute;m. Khi dữ liệu trong cơ sở dữ liệu kh&ocirc;ng thay đổi, việc n&agrave;y kh&ocirc;ng g&acirc;y ra vấn đề về chi ph&iacute;. Tuy nhi&ecirc;n, đối với c&aacute;c gi&aacute; trị c&oacute; thể thay đổi, ch&uacute;ng ta cần một cơ chế đọc lại gi&aacute; trị trong cơ sở dữ liệu định kỳ. Gi&aacute; trị được lưu trong bộ đệm, trong trường hợp đ&oacute;, trở n&ecirc;n kh&ocirc;ng hợp lệ (hết hạn) v&agrave; ch&uacute;ng ta kh&ocirc;ng muốn ứng dụng cung cấp một gi&aacute; trị cũ cho người d&ugrave;ng. Điều n&agrave;y c&oacute; thể được giải quyết bằng một goroutine v&agrave; đối tượng <code>Ticker</code>.

Channel, Timeout và Ticker