Thời gian trong Golang: Now, Sleep, Format, Parse, Duration

Kiến thức cơ bản trong một chương trình

package main

import (
	"fmt"
	"time"
)

func main() {
	start := time.Now()

	time.Sleep(50 * time.Millisecond)

	elapsed := time.Since(start)
	fmt.Println("slept at least 50ms:", elapsed >= 50*time.Millisecond)

	t := time.Date(2026, time.September, 23, 14, 30, 0, 0, time.UTC)
	fmt.Println(t)
	fmt.Println(t.Format("2006-01-02 15:04"))
	fmt.Println(t.Format("Monday, January 2, 2006"))
	fmt.Println("in 90 minutes:", t.Add(90*time.Minute).Format(time.Kitchen))
}

time.Now() trả về thời gian địa phương hiện tại, time.Sleep tạm dừng goroutine hiện tại, time.Since đo thời gian đã trôi qua, và time.Date dựng một thời điểm cụ thể. Phần còn lại của trang lần lượt đi qua từng phần. Các ví dụ dùng ngày cố định và múi giờ UTC để đầu ra giống nhau dù bạn chạy ở đâu.

Sleep và Duration

time.Duration là một int64 đếm số nano giây. Package này định nghĩa sẵn các hằng số để tạo giá trị dễ đọc:

Không có time.Day, vì một ngày không phải lúc nào cũng dài 24 giờ khi múi giờ đổi sang giờ mùa hè. Dùng AddDate cho ngày theo lịch (xem bên dưới).

package main

import (
	"fmt"
	"time"
)

func main() {
	d := 90 * time.Minute
	fmt.Println(d)                      // 1h30m0s
	fmt.Println(d.Hours(), d.Minutes()) // float64 values
	fmt.Println(2*time.Hour + 15*time.Second)

	// Multiplying by a variable needs a conversion: int * Duration does not compile.
	retries := 3
	backoff := time.Duration(retries) * 200 * time.Millisecond
	fmt.Println("backoff:", backoff)

	// Parse a duration from a string (for flags and config files).
	timeout, err := time.ParseDuration("1m30s")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("timeout:", timeout, "=", timeout.Seconds(), "seconds")

	// Round and truncate a measured duration for display.
	measured := 1234567891 * time.Nanosecond
	fmt.Println(measured, measured.Round(time.Millisecond), measured.Truncate(time.Second))
}

Hai bug thường gặp xuất phát từ việc Duration là số nguyên:

• time.Sleep(5) chỉ ngủ 5 nano giây. Luôn nhân với một đơn vị: time.Sleep(5 * time.Second).
• time.Sleep(n * time.Second) không biên dịch được khi n là biến kiểu int. Hãy chuyển đổi: time.Duration(n) * time.Second. Một hằng số như 5 dùng được mà không cần chuyển đổi, vì hằng số không có kiểu tự thích nghi với kiểu Duration.

ParseDuration chấp nhận ns, us (hoặc µs), ms, s, m và h, kết hợp như "2h45m" hay "1.5s". Nó không có đơn vị cho ngày.

Định dạng: layout mẫu 2006-01-02

Go không dùng %Y-%m-%d hay yyyy-MM-dd. Layout là thời điểm mẫu

Mon Jan 2 15:04:05 MST 2006

được viết theo đúng hình dạng bạn muốn đầu ra trông như thế. Các giá trị được chọn sao cho mỗi giá trị là duy nhất: tháng 1, ngày 2, giờ 3 (hoặc 15), phút 4, giây 5, năm 6 (2006), độ lệch múi giờ -7 (-0700). Hãy đọc nó là 01/02 03:04:05PM '06 -0700.

package main

import (
	"fmt"
	"time"
)

func main() {
	t := time.Date(2026, time.March, 5, 9, 7, 3, 250_000_000, time.UTC)

	layouts := []string{
		"2006-01-02",
		"02/01/2006",
		"01/02/06",
		"Jan 2, 2006",
		"Monday 2 January 2006",
		"15:04:05",
		"3:04 PM",
		"2006-01-02T15:04:05.000Z07:00",
		time.RFC3339,
		time.DateTime,
		time.RFC1123,
	}
	for _, l := range layouts {
		fmt.Printf("%-32q %s\n", l, t.Format(l))
	}
}

Các token layout bạn sẽ cần nhiều nhất:

Các layout định nghĩa sẵn:

Lỗi kinh điển là viết layout với số sai, ví dụ "2023-01-01". Go không từ chối nó. Go chép nguyên các ký tự nó không nhận ra và thay thế những ký tự nó nhận ra: mỗi 2 là ngày, 3 là giờ theo đồng hồ 12 giờ và cả hai 01 là tháng, nên ngày 5 tháng 3 lúc 9:07 sẽ được định dạng thành 5059-03-03. Một layout như "YYYY-MM-DD" không chứa token nào và in ra y nguyên chính nó. Nếu ngày được định dạng trông lạ, hãy kiểm tra layout có dùng đúng các giá trị mẫu không.

Phân tích chuỗi thành thời gian

time.Parse(layout, value) dùng cùng các layout đó, và trả về một lỗi bạn phải kiểm tra:

package main

import (
	"fmt"
	"time"
)

func main() {
	t, err := time.Parse("2006-01-02 15:04", "2026-09-23 18:45")
	if err != nil {
		fmt.Println("parse error:", err)
		return
	}
	fmt.Println(t, "| location:", t.Location())

	// A string with an offset keeps that offset.
	t2, err := time.Parse(time.RFC3339, "2026-09-23T18:45:00+02:00")
	if err != nil {
		fmt.Println("parse error:", err)
		return
	}
	fmt.Println(t2, "| in UTC:", t2.UTC())

	// Interpret a zone-less string in a specific zone.
	tokyo := time.FixedZone("JST", 9*60*60)
	t3, err := time.ParseInLocation(time.DateTime, "2026-09-23 18:45:00", tokyo)
	if err != nil {
		fmt.Println("parse error:", err)
		return
	}
	fmt.Println(t3, "| in UTC:", t3.UTC())

	// A wrong input produces a descriptive error.
	_, err = time.Parse(time.DateOnly, "23/09/2026")
	fmt.Println("error:", err)
}

Nếu đầu vào không có múi giờ, Parse trả về UTC. Cùng một chuỗi giờ đồng hồ có thể là những thời điểm khác nhau tùy theo múi giờ, vì thế mới có ParseInLocation. Thông báo lỗi nêu tên phần không khớp, rất có ích khi bạn gỡ lỗi một layout.

Múi giờ

time.Time là một thời điểm cộng với một location dùng khi hiển thị. Đổi location bằng In chỉ thay đổi cách nó được in ra, không thay đổi thời điểm.

package main

import (
	"fmt"
	"time"
	_ "time/tzdata" // embed the zone database so LoadLocation works anywhere
)

func main() {
	meeting := time.Date(2026, time.September, 23, 15, 0, 0, 0, time.UTC)

	ny, err := time.LoadLocation("America/New_York")
	if err != nil {
		fmt.Println("load location:", err)
		return
	}
	india := time.FixedZone("IST", 5*60*60+30*60) // +05:30, no DST rules

	fmt.Println("UTC:     ", meeting.Format(time.RFC1123))
	fmt.Println("New York:", meeting.In(ny).Format(time.RFC1123))
	fmt.Println("India:   ", meeting.In(india).Format(time.RFC1123))
	fmt.Println("same instant:", meeting.Equal(meeting.In(ny)))
}

• time.UTC luôn có sẵn. Hãy lưu trữ và truyền thời gian ở UTC (hoặc RFC 3339 kèm độ lệch) và chỉ chuyển đổi khi hiển thị.
• time.Local là múi giờ của máy. Trên máy chủ và trong container nó thường là UTC, còn trên laptop thì không, nên code phụ thuộc vào nó sẽ chạy khác nhau ở mỗi nơi.
• time.LoadLocation("Europe/Berlin") đọc cơ sở dữ liệu IANA từ hệ điều hành. Các image container tối giản thường không có nó, và khi đó lời gọi trả về lỗi. Import trống _ "time/tzdata" nhúng cơ sở dữ liệu này vào tệp nhị phân của bạn (khoảng 450 KB) để nó luôn chạy được. Luôn xử lý lỗi.
• time.FixedZone(name, offsetSeconds) tạo một múi giờ có độ lệch cố định. Nó không có quy tắc giờ mùa hè, nên hãy dùng nó cho các độ lệch bạn nhận được, không phải cho các vùng có tên.

Tính toán và so sánh

package main

import (
	"fmt"
	"time"
)

func main() {
	start := time.Date(2026, time.January, 31, 10, 0, 0, 0, time.UTC)
	end := time.Date(2026, time.March, 1, 12, 30, 0, 0, time.UTC)

	fmt.Println("difference:", end.Sub(start))
	fmt.Println("in days:   ", int(end.Sub(start).Hours()/24))

	fmt.Println("+36h:      ", start.Add(36*time.Hour).Format(time.DateTime))
	fmt.Println("-1 week:   ", start.AddDate(0, 0, -7).Format(time.DateOnly))
	fmt.Println("+1 month:  ", start.AddDate(0, 1, 0).Format(time.DateOnly)) // Jan 31 + 1 month

	fmt.Println("before:", start.Before(end), "after:", start.After(end), "equal:", start.Equal(end))

	// Start of the day, and parts of a date.
	y, m, d := end.Date()
	midnight := time.Date(y, m, d, 0, 0, 0, 0, end.Location())
	fmt.Println("midnight:", midnight.Format(time.DateTime))
	fmt.Println("weekday:", end.Weekday(), "day of year:", end.YearDay())

	// Unix timestamps.
	fmt.Println("unix:", start.Unix(), "ms:", start.UnixMilli())
	fmt.Println("from unix:", time.Unix(1_790_000_000, 0).UTC())
}

Những điều cần chú ý trong đầu ra:

• AddDate(0, 1, 0) vào ngày 31 tháng 1 cho ra ngày 3 tháng 3, không phải ngày 28 tháng 2. Go cộng một tháng để có "ngày 31 tháng 2" rồi chuẩn hóa phần tràn. Nếu bạn cần "cùng ngày tháng sau, giới hạn ở cuối tháng", hãy tự viết logic đó.
• Sub trả về một Duration, tối đa khoảng 292 năm. Để tính chênh lệch theo ngày lịch, hãy so sánh các ngày lúc nửa đêm UTC rồi chia cho 24 giờ.
• Để lấy đầu ngày, hãy dựng lại thời gian từ Date(). t.Truncate(24 * time.Hour) làm tròn so với thời điểm zero ở UTC, nên cho kết quả sai với mọi múi giờ khác UTC.

So sánh bằng Equal, Before, After, không bao giờ bằng ==. time.Now() có kèm giá trị đọc từ đồng hồ đơn điệu (monotonic clock), dùng để time.Since vẫn đúng khi đồng hồ hệ thống bị chỉnh. == so sánh cả giá trị đó lẫn location, nên hai giá trị Time cùng một thời điểm vẫn có thể không bằng nhau. Cũng vì lý do này, đừng dùng time.Time làm khóa của map khi chưa chuẩn hóa (t.UTC().Round(0) bỏ đi giá trị đồng hồ đơn điệu).

time.Time zero là ngày 1 tháng 1 năm 1, 00:00 UTC. Kiểm tra nó bằng t.IsZero().

Đo thời gian đã trôi qua

start := time.Now()
doWork()
log.Printf("doWork took %v", time.Since(start))

time.Since(start) chính là time.Now().Sub(start), và time.Until(deadline) là deadline.Sub(time.Now()). Cả hai dùng đồng hồ đơn điệu khi có, nên an toàn trước những lần đồng hồ hệ thống thay đổi. Để benchmark code, hãy dùng tính năng benchmark của Go trong package testing thay vì tự bấm giờ.

Timer và ticker

time.After(d) trả về một channel nhận đúng một giá trị sau d. time.Timer cũng vậy nhưng có thêm phương thức Stop. time.Ticker gửi một giá trị sau mỗi chu kỳ cho đến khi bạn dừng nó.

package main

import (
	"fmt"
	"time"
)

func main() {
	ticker := time.NewTicker(20 * time.Millisecond)
	defer ticker.Stop()

	done := time.NewTimer(110 * time.Millisecond)
	defer done.Stop()

	ticks := 0
	for {
		select {
		case <-ticker.C:
			ticks++
			fmt.Println("tick", ticks)
			if ticks == 3 {
				fmt.Println("got three ticks, stopping early")
				return
			}
		case <-done.C:
			fmt.Println("timer fired first")
			return
		}
	}
}

Ba tick lúc 20, 40 và 60 ms đến sớm hơn nhiều so với timer 110 ms, nên chương trình dừng sau tick thứ ba. time.AfterFunc(d, f) chạy f trong goroutine riêng sau d, rất tiện cho việc trì hoãn chạy một lần.

Từ Go 1.23, timer và ticker không còn được tham chiếu sẽ bị thu gom rác kể cả khi bạn không gọi Stop, và channel của timer đã dừng hoặc đã đặt lại không còn gửi giá trị cũ nữa. Gọi Stop bằng defer vẫn là cách rõ ràng để nói vòng đời của ticker đã kết thúc. Khi giới hạn thời gian áp dụng cho cả một thao tác chứ không phải một lần chờ, context.WithTimeout thường dễ đọc hơn timer.

Thời gian trong JSON

time.Time tự động được chuyển sang và từ chuỗi RFC 3339 trong JSON, với độ chính xác đến nano giây:

type Event struct {
	Name string    `json:"name"`
	At   time.Time `json:"at"`
}
// {"name":"deploy","at":"2026-09-23T14:30:00Z"}

Chuỗi JSON ở định dạng khác sẽ không unmarshal được. Với Unix timestamp hoặc định dạng tùy chỉnh, hãy lưu một int64 hoặc một chuỗi rồi chuyển đổi, hoặc định nghĩa một kiểu có UnmarshalJSON riêng.

Lỗi thường gặp

• time.Sleep(1) hoặc time.Sleep(n) với một số trần. Đó là nano giây.
• Layout với chữ số sai. "2023-01-01" hay "YYYY-MM-DD" không phải layout. Hãy dùng "2006-01-02".
• Nhầm phút với tháng. Phút là 04, tháng là 01. "15:01" in ra giờ rồi đến tháng, không phải phút.
• So sánh bằng ==. Hãy dùng Equal.
• Dựa vào time.Local. Nó khác nhau giữa các máy. Hãy ghi rõ time.UTC hoặc một location đã nạp.
• Bỏ qua lỗi từ LoadLocation hoặc Parse. Cả hai đều thất bại với đầu vào thực tế. Parse thất bại trả về thời điểm zero, in ra là năm 1, còn LoadLocation thất bại trả về location nil khiến t.In(loc) bị panic.