Работа с горутинами в Go часто напоминает управление непослушными детьми - они разбегаются кто куда, делают что хотят и не всегда завершаются вовремя. К счастью, в Go 1.7 появился пакет context, который помогает держать эту ватагу под контролем.
Предположим, есть веб-сервер, обрабатывающий тысячи запросов. Пользователь закрыл вкладку браузера, но сервер продолжает обработку - запрашивает данные из базы, отправляет запросы к микросервисам, выполняет тяжёлые вычисления. Всё это пожирает ресурсы впустую. Или другой пример - микросервис ждёт ответа от внешнего API дольше допустимого времени. Без механизма отмены операций приложение рискует застрять в подвешенном состоянии. Context решает эти проблемы элегантно и единообразно. По сути, это интерфейс для управления жизненным циклом горутин и передачи данных между ними. Главная его задача - организовать своевременную отмену операций и освобождение ресурсов.
| Go | 1
2
3
4
5
6
7
8
| func longOperation(ctx context.Context) error {
select {
case <-time.After(2 * time.Second):
return nil
case <-ctx.Done():
return ctx.Err()
}
} |
|
Context особенно полезен при построении распределённых систем. Когда запрос проходит через несколько микросервисов, контекст позволяет распространить сигнал отмены по всей цепочке вызовов. Если первый сервис определяет, что клиент отключился, все последующие операции могут быть gracefully остановлены. Кроме отмены операций, Context предоставляет механизм для передачи значений между горутинами. Это может быть идентификатор запроса, данные авторизации или метаданные для трейсинга. Важно понимать, что этот механизм не заменяет явную передачу параметров через аргументы функций - он предназначен для передачи служебной информации, которая должна быть доступна во всей цепочке вызовов.
| Go | 1
2
3
| ctx := context.WithValue(parentCtx, "requestID", "12345")
// Где-то в глубине стека вызовов
requestID := ctx.Value("requestID").(string) |
|
Архитектура и основные типы
Основа пакета context - интерфейс Context, определяющий четыре метода. Метод Done() возвращает канал, который закрывается при отмене контекста. Err() сообщает причину отмены. Deadline() возвращает крайний срок выполнения, если он установлен. Value() позволяет получить значение по ключу.
| Go | 1
2
3
4
5
6
| type Context interface {
Done() <-chan struct{}
Err() error
Deadline() (deadline time.Time, ok bool)
Value(key any) any
} |
|
| Go | 1
2
3
| rootCtx := context.Background()
// TODO обычно используется временно при разработке
tempCtx := context.TODO() |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
| ctx, cancel := context.WithCancel(parentCtx)
go func() {
defer cancel() // Гарантируем отмену при выходе
for {
select {
case <-ctx.Done():
return
default:
// Продолжаем работу
}
}
}() |
|
| Go | 1
2
3
4
5
6
7
8
9
10
| ctx, cancel := context.WithTimeout(parentCtx, 5*time.Second)
defer cancel()
// Где-то в другой горутине
select {
case <-time.After(6 * time.Second):
fmt.Println("Операция превысила таймаут")
case <-ctx.Done():
fmt.Printf("Контекст отменён: %v\n", ctx.Err())
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
| type ctxKey string
func WithUserID(ctx context.Context, userID string) context.Context {
return context.WithValue(ctx, ctxKey("userID"), userID)
}
func GetUserID(ctx context.Context) (string, bool) {
id, ok := ctx.Value(ctxKey("userID")).(string)
return id, ok
} |
|
Важно понимать, что контекст иммутабелен - нельзя изменить дедлайн или добавить значение в существующий контекст. Вместо этого создаётся новый контекст-потомок с обновлёнными параметрами. Это гарантирует потокобезопасность и предотвращает гонки данных. При работе с таймаутами стоит учитывать накладные расходы. Каждый WithTimeout/WithDeadline создаёт таймер, который потребляет системные ресурсы. В высоконагруженных системах лучше переиспользовать контексты с одинаковыми временными ограничениями. Исследования показывают интересную закономерность: большинство утечек памяти в Go-приложениях связано с некорректным использованием контекста в цепочках горутин. Контекст не просто передаёт сигнал отмены - он создаёт связанный граф горутин, где каждая операция знает о своих зависимостях.
Внутри пакета context используется хитрая механика для отслеживания зависимостей между горутинами. Каждый контекст хранит ссылку на родителя и список своих потомков. При отмене контекста сначала закрывается канал Done(), затем рекурсивно отменяются все потомки. Это происходит атомарно, без блокировок и гонок данных:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| type cancelCtx struct {
Context
mu sync.Mutex
done chan struct{}
children map[canceler]struct{}
err error
}
func (c *cancelCtx) cancel(removeFromParent bool, err error) {
c.mu.Lock()
if c.err != nil {
c.mu.Unlock()
return // Уже отменён
}
c.err = err
close(c.done)
for child := range c.children {
child.cancel(false, err)
}
c.children = nil
c.mu.Unlock()
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| func processWithTimeout(ctx context.Context, data []byte) error {
ch := make(chan error, 1)
go func() {
// Тяжёлая обработка
result := heavyProcessing(data)
ch <- result
}()
select {
case err := <-ch:
return err
case <-ctx.Done():
return fmt.Errorf("операция отменена: %w", ctx.Err())
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
| if err := longOperation(ctx); err != nil {
switch {
case errors.Is(err, context.Canceled):
log.Info("операция штатно отменена")
case errors.Is(err, context.DeadlineExceeded):
log.Warn("превышен таймаут операции")
default:
log.Error("ошибка выполнения", err)
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
| func getValue(ctx context.Context, key interface{}) interface{} {
if v := ctx.Value(key); v != nil {
return v
}
if parent, ok := ctx.(*cancelCtx); ok {
return getValue(parent.Context, key) // Рекурсивный поиск
}
return nil
} |
|
- Хранить часто используемые значения ближе к листьям дерева контекстов.
- Кэшировать результаты Value() если они используются многократно.
- Не злоупотреблять глубокой вложенностью контекстов.
При реализации собственных типов контекста важно соблюдать контракт интерфейса Context. Например, канал Done() должен быть неизменяемым и закрываться только один раз. Значения, возвращаемые Value(), должны быть потокобезопасными. Нарушение этих правил приводит к сложно отлавливаемым багам. В высоконагруженных системах стоит следить за количеством создаваемых контекстов. Каждый WithTimeout/WithDeadline allocation создаёт новый таймер в runtime. При миллионах запросов это может создать существенную нагрузку на планировщик горутин.
| Go | 1
2
3
4
5
6
7
8
9
10
11
| // Плохо - создаём новый контекст на каждый запрос
for req := range requests {
ctx, _ := context.WithTimeout(context.Background(), time.Second)
process(ctx, req)
}
// Лучше - переиспользуем контекст с одинаковым таймаутом
baseCtx, _ := context.WithTimeout(context.Background(), time.Second)
for req := range requests {
process(baseCtx, req)
} |
|
Пакет для работы с файлами офиса из Golang (создание, чтение xls, xlsx, doc, docx, rtf)
Ребята, подскажите, пожалуйста, хороший пакет для работы с файлами офиса из Golang (создание, чтение xls, xlsx, doc, docx, rtf).
Пока нашёл... Пакет Context и его применение
Ну и ещё вопрос, из того что поднакопилось:
Есть такой пакет, который описывает нечто как "контекст" (исполнения? или чего?) Описание... Acme+9P+Golang+MongoDB=mongofs
Поскольку на работе я использую Go, MongoDB и Acme, решил написать файлсервер для удобного доступа к базе из Acme. Вот что пока получилось:... Создание форм в Golang?
Доброго времени суток! Интересует создание форм в Go. Есть какой то редактор форм в IDE для Go?
Или как можно создать формы под Linux'ом?
Заранее...
Практическое применение
Главное преимущество context проявляется при построении конкурентных приложений. Рассмотрим типичные сценарии использования этого механизма в реальных проектах. Отмена HTTP-запросов - один из самых распространённых случаев. Когда клиент разрывает соединение, нужно остановить всю связанную обработку:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| func handleRequest(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
results := make(chan []byte, 1)
go func() {
data, err := queryDatabase(ctx)
if err != nil {
return
}
results <- processData(ctx, data)
}()
select {
case result := <-results:
w.Write(result)
case <-ctx.Done():
log.Printf("Клиент отключился: %v", ctx.Err())
return
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| func updateUserData(ctx context.Context, userID string, data UserData) error {
tx, err := db.BeginTx(ctx, nil)
if err != nil {
return fmt.Errorf("начало транзакции: %w", err)
}
defer tx.Rollback()
if err := tx.QueryRowContext(ctx,
"UPDATE users SET data = $1 WHERE id = $2",
data, userID).Err(); err != nil {
return fmt.Errorf("обновление данных: %w", err)
}
if err := tx.Commit(); err != nil {
return fmt.Errorf("фиксация транзакции: %w", err)
}
return nil
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| func (s *Service) ProcessOrder(ctx context.Context, order Order) error {
span := trace.SpanFromContext(ctx)
defer span.End()
// Добавляем данные пользователя
ctx = WithUserInfo(ctx, order.UserID)
// Проверяем товары
if err := s.inventory.Check(ctx, order.Items); err != nil {
return err
}
// Резервируем оплату
payment, err := s.payments.Reserve(ctx, order.Total)
if err != nil {
return err
}
// Создаём доставку
shipment, err := s.shipping.Create(ctx, order.Address)
if err != nil {
s.payments.Cancel(ctx, payment.ID)
return err
}
return nil
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| func (s *Server) Shutdown(timeout time.Duration) error {
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
// Останавливаем приём новых запросов
s.listener.Close()
// Ждём завершения текущих
done := make(chan struct{})
go func() {
s.wg.Wait()
close(done)
}()
select {
case <-done:
return nil
case <-ctx.Done():
return fmt.Errorf("превышен таймаут shutdown: %v", ctx.Err())
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| func (c *Client) callWithRetry(ctx context.Context, req Request) (*Response, error) {
backoff := time.Second
for attempts := 0; attempts < 3; attempts++ {
resp, err := c.doRequest(ctx, req)
if err == nil {
return resp, nil
}
// Проверяем отмену контекста
if ctx.Err() != nil {
return nil, ctx.Err()
}
// Временная ошибка - делаем паузу
if errors.Is(err, ErrTemporary) {
select {
case <-time.After(backoff):
backoff *= 2
case <-ctx.Done():
return nil, ctx.Err()
}
continue
}
// Постоянная ошибка
return nil, err
}
return nil, ErrMaxRetriesExceeded
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| func NewWorkerPool(ctx context.Context, size int) *WorkerPool {
pool := &WorkerPool{
work: make(chan Job),
done: make(chan struct{}),
}
for i := 0; i < size; i++ {
go func() {
for {
select {
case job := <-pool.work:
// Проверяем отмену перед каждой задачей
if ctx.Err() != nil {
return
}
job.Execute(ctx)
case <-ctx.Done():
return
}
}
}()
}
return pool
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| func (s *Service) StreamData(req *pb.Request, stream pb.Service_StreamDataServer) error {
ctx := stream.Context()
for {
select {
case <-ctx.Done():
return ctx.Err()
default:
data, err := s.processChunk(ctx)
if err != nil {
return err
}
if err := stream.Send(data); err != nil {
return err
}
}
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| func (s *Service) HandleRequest(ctx context.Context, req *Request) (*Response, error) {
spanCtx, span := tracer.Start(ctx, "process-request")
defer span.End()
// Добавляем данные о текущем сервисе
span.SetAttributes(
attribute.String("service.name", s.name),
attribute.String("request.id", req.ID),
)
// Вызываем другие сервисы с обогащённым контекстом
result, err := s.nextService.Process(spanCtx, req)
if err != nil {
span.RecordError(err)
return nil, err
}
return result, nil
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| func (c *Cache) GetOrCompute(ctx context.Context, key string, compute func() interface{}) interface{} {
if val, ok := c.Get(key); ok {
return val
}
result := make(chan interface{}, 1)
go func() {
value := compute()
select {
case result <- value:
// Результат использован
case <-ctx.Done():
// Сохраняем для будущих запросов
c.Set(key, value)
}
}()
select {
case val := <-result:
return val
case <-ctx.Done():
return nil
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| func (c *Consumer) ProcessMessages(ctx context.Context) {
for {
select {
case msg := <-c.messages:
processCtx, cancel := context.WithTimeout(ctx, time.Second*30)
err := c.processMessage(processCtx, msg)
if err != nil {
if errors.Is(err, context.DeadlineExceeded) {
c.nack(msg)
} else {
c.deadLetter(msg)
}
}
cancel()
case <-ctx.Done():
c.shutdown()
return
}
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
| func (l *Limiter) Execute(ctx context.Context, fn func() error) error {
select {
case <-l.tokens:
defer func() { l.tokens <- struct{}{} }()
return fn()
case <-ctx.Done():
return fmt.Errorf("превышен лимит запросов: %w", ctx.Err())
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| type Config struct {
Timeout time.Duration
RetryCount int
Features map[string]bool
}
func WithConfig(ctx context.Context, cfg *Config) context.Context {
return context.WithValue(ctx, configKey, cfg)
}
func GetConfig(ctx context.Context) *Config {
cfg, _ := ctx.Value(configKey).(*Config)
return cfg
}
func (s *Service) Process(ctx context.Context, req Request) error {
cfg := GetConfig(ctx)
if !cfg.Features["new_processing"] {
return s.legacyProcess(ctx, req)
}
retryCtx, cancel := context.WithTimeout(ctx, cfg.Timeout)
defer cancel()
return retry.Do(retryCtx, cfg.RetryCount, func() error {
return s.newProcess(retryCtx, req)
})
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| func TestLongOperation(t *testing.T) {
t.Run("успешное выполнение", func(t *testing.T) {
ctx := context.Background()
result, err := LongOperation(ctx)
require.NoError(t, err)
assert.NotNil(t, result)
})
t.Run("отмена операции", func(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
go func() {
time.Sleep(time.Millisecond * 100)
cancel()
}()
_, err := LongOperation(ctx)
require.ErrorIs(t, err, context.Canceled)
})
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| func copyLargeFile(ctx context.Context, src, dst string) error {
srcFile, err := os.Open(src)
if err != nil {
return fmt.Errorf("открытие исходного файла: %w", err)
}
defer srcFile.Close()
dstFile, err := os.Create(dst)
if err != nil {
return fmt.Errorf("создание целевого файла: %w", err)
}
defer dstFile.Close()
buf := make([]byte, 32*1024)
for {
select {
case <-ctx.Done():
return ctx.Err()
default:
n, err := srcFile.Read(buf)
if err == io.EOF {
return nil
}
if err != nil {
return err
}
if _, err := dstFile.Write(buf[:n]); err != nil {
return err
}
}
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| func runPeriodicTask(ctx context.Context, interval time.Duration, task func() error) error {
ticker := time.NewTicker(interval)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return ctx.Err()
case <-ticker.C:
if err := task(); err != nil {
log.Printf("ошибка выполнения задачи: %v", err)
}
}
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| func trackOperation(ctx context.Context, name string) func() {
start := time.Now()
span := trace.FromContext(ctx).NewChild(name)
return func() {
duration := time.Since(start)
metrics.OperationDuration.WithLabelValues(name).Observe(duration.Seconds())
span.End()
}
}
func processData(ctx context.Context, data []byte) error {
defer trackOperation(ctx, "process_data")()
// Длительная обработка
for chunk := range splitData(data) {
select {
case <-ctx.Done():
return ctx.Err()
default:
if err := processChunk(chunk); err != nil {
return err
}
}
}
return nil
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
| type BackgroundJob struct {
ctx context.Context
cancel context.CancelFunc
done chan struct{}
}
func NewBackgroundJob() *BackgroundJob {
ctx, cancel := context.WithCancel(context.Background())
return &BackgroundJob{
ctx: ctx,
cancel: cancel,
done: make(chan struct{}),
}
}
func (j *BackgroundJob) Start() {
go func() {
defer close(j.done)
ticker := time.NewTicker(time.Minute)
defer ticker.Stop()
for {
select {
case <-j.ctx.Done():
return
case <-ticker.C:
j.doWork()
}
}
}()
}
func (j *BackgroundJob) Stop() error {
j.cancel()
select {
case <-j.done:
return nil
case <-time.After(30 * time.Second):
return errors.New("таймаут остановки")
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| type CacheEntry struct {
Value interface{}
Expiration time.Time
}
func (c *Cache) GetOrCompute(ctx context.Context, key string, compute func() (interface{}, error)) (interface{}, error) {
// Проверяем кэш
if entry, ok := c.get(key); ok && entry.Expiration.After(time.Now()) {
return entry.Value, nil
}
// Вычисляем новое значение
value, err := compute()
if err != nil {
return nil, err
}
// Сохраняем в кэш, если контекст не отменён
select {
case <-ctx.Done():
return value, nil
default:
c.set(key, CacheEntry{
Value: value,
Expiration: time.Now().Add(c.ttl),
})
return value, nil
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| type Pool struct {
connections chan net.Conn
factory func(context.Context) (net.Conn, error)
}
func (p *Pool) Acquire(ctx context.Context) (net.Conn, error) {
select {
case conn := <-p.connections:
return conn, nil
case <-ctx.Done():
return nil, ctx.Err()
default:
return p.factory(ctx)
}
}
func (p *Pool) Release(conn net.Conn) {
select {
case p.connections <- conn:
// Соединение возвращено в пул
default:
conn.Close()
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| func (q *Queue) Process(ctx context.Context, handler func([]byte) error) error {
for {
select {
case <-ctx.Done():
return ctx.Err()
case msg := <-q.messages:
// Создаём отдельный контекст для обработки сообщения
msgCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
err := handler(msg)
if err != nil {
if errors.Is(err, context.DeadlineExceeded) {
q.requeue(msg)
} else {
q.markFailed(msg)
}
}
cancel()
}
}
} |
|
Продвинутые техники и рекомендации
При работе с context важно избегать утечек горутин. Частая ошибка - забытый вызов cancel(). Хорошая практика - использовать defer сразу после создания контекста:
| Go | 1
2
3
4
5
6
| func longProcess() error {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel() // Гарантируем вызов даже при панике
return doWork(ctx)
} |
|
| Go | 1
2
3
4
5
6
7
| type Service interface {
// Правильно
Process(ctx context.Context, data []byte) error
// Неправильно
AnotherProcess(data []byte, ctx context.Context) error
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| func TestWithCancellation(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
errors := make(chan error, 1)
go func() {
errors <- longOperation(ctx)
}()
// Отменяем через случайный интервал
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
cancel()
err := <-errors
if !errors.Is(err, context.Canceled) {
t.Errorf("ожидалась ошибка отмены, получено: %v", err)
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| type Pool struct {
contexts map[time.Duration]context.Context
cancels map[time.Duration]context.CancelFunc
mu sync.RWMutex
}
func (p *Pool) GetContext(timeout time.Duration) context.Context {
p.mu.RLock()
if ctx, ok := p.contexts[timeout]; ok {
p.mu.RUnlock()
return ctx
}
p.mu.RUnlock()
p.mu.Lock()
defer p.mu.Unlock()
ctx, cancel := context.WithTimeout(context.Background(), timeout)
p.contexts[timeout] = ctx
p.cancels[timeout] = cancel
return ctx
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
| type contextKey struct {
name string
}
var (
userIDKey = &contextKey{"userID"}
traceIDKey = &contextKey{"traceID"}
)
// Теперь коллизии невозможны
ctx = context.WithValue(ctx, userIDKey, "12345") |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
| func WithMetrics(ctx context.Context, name string) (context.Context, func()) {
start := time.Now()
return ctx, func() {
duration := time.Since(start)
if ctx.Err() != nil {
metrics.FailedOperations.WithLabelValues(name).Inc()
}
metrics.OperationDuration.WithLabelValues(name).Observe(duration.Seconds())
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| type App struct {
ctx context.Context
cancel context.CancelFunc
state *State
}
func (a *App) Shutdown() error {
a.cancel()
// Даём время на сохранение
deadline := time.Now().Add(30 * time.Second)
ctx, cancel := context.WithDeadline(context.Background(), deadline)
defer cancel()
return a.state.Save(ctx)
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
| // Неправильно
type BadService struct {
ctx context.Context
}
// Правильно
type GoodService struct {
// Конфигурация и зависимости
}
func (s *GoodService) Process(ctx context.Context) error {
// Контекст передаётся в метод
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| type Client struct {
httpClient *http.Client
baseURL string
}
func (c *Client) Do(ctx context.Context, method, path string) (*Response, error) {
req, err := http.NewRequestWithContext(ctx, method, c.baseURL+path, nil)
if err != nil {
return nil, err
}
resp, err := c.httpClient.Do(req)
if err != nil {
// Проверяем, не отменён ли контекст
if ctx.Err() != nil {
return nil, ctx.Err()
}
return nil, err
}
return parseResponse(resp)
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| type ContextPool struct {
mu sync.RWMutex
pool map[time.Duration]*PooledContext
cleaner *time.Ticker
}
type PooledContext struct {
ctx context.Context
cancel context.CancelFunc
refs int32
}
func (p *ContextPool) Get(timeout time.Duration) context.Context {
p.mu.RLock()
if pc, ok := p.pool[timeout]; ok {
atomic.AddInt32(&pc.refs, 1)
p.mu.RUnlock()
return pc.ctx
}
p.mu.RUnlock()
ctx, cancel := context.WithTimeout(context.Background(), timeout)
pc := &PooledContext{ctx, cancel, 1}
p.mu.Lock()
p.pool[timeout] = pc
p.mu.Unlock()
return ctx
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| func withLogging(ctx context.Context, op string) (context.Context, func()) {
start := time.Now()
logger := log.FromContext(ctx)
return ctx, func() {
duration := time.Since(start)
switch ctx.Err() {
case context.Canceled:
logger.Info("операция отменена",
"operation", op,
"duration", duration)
case context.DeadlineExceeded:
logger.Warn("превышен таймаут",
"operation", op,
"duration", duration)
case nil:
logger.Debug("операция завершена",
"operation", op,
"duration", duration)
}
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| func retryWithBackoff(ctx context.Context, op func() error) error {
backoff := time.Second
maxBackoff := time.Minute
for attempt := 1; ; attempt++ {
err := op()
if err == nil {
return nil
}
if !isRetryable(err) || ctx.Err() != nil {
return err
}
nextBackoff := backoff * time.Duration(attempt)
if nextBackoff > maxBackoff {
nextBackoff = maxBackoff
}
timer := time.NewTimer(nextBackoff)
select {
case <-timer.C:
continue
case <-ctx.Done():
timer.Stop()
return ctx.Err()
}
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| type metrics struct {
activeContexts prometheus.Gauge
contextCreated prometheus.Counter
contextCanceled prometheus.Counter
contextDeadline prometheus.Counter
}
func trackContext(ctx context.Context) func() {
m.activeContexts.Inc()
m.contextCreated.Inc()
return func() {
m.activeContexts.Dec()
switch ctx.Err() {
case context.Canceled:
m.contextCanceled.Inc()
case context.DeadlineExceeded:
m.contextDeadline.Inc()
}
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| type ClientOption func(*Client)
func WithoutDeadlines(c *Client) {
c.timeouts = false
}
func (c *Client) execute(ctx context.Context, req Request) (*Response, error) {
if !c.timeouts {
return c.doRequest(ctx, req)
}
ctx, cancel := context.WithTimeout(ctx, c.defaultTimeout)
defer cancel()
return c.doRequest(ctx, req)
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| func TestCancellation(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
done := make(chan struct{})
go func() {
defer close(done)
if err := longOperation(ctx); !errors.Is(err, context.Canceled) {
t.Errorf("unexpected error: %v", err)
}
}()
// Имитируем внешнюю отмену
time.Sleep(100 * time.Millisecond)
cancel()
select {
case <-done:
// Операция корректно отменена
case <-time.After(time.Second):
t.Error("operation not canceled in time")
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| func preservingContext(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
originalCtx := r.Context()
enrichedCtx := context.WithValue(originalCtx, "startTime", time.Now())
r = r.WithContext(enrichedCtx)
next.ServeHTTP(w, r)
// Доступ к оригинальному контексту при необходимости
if deadline, ok := originalCtx.Deadline(); ok {
log.Printf("Original deadline: %v", deadline)
}
})
} |
|
Альтернативы и ограничения
Context - мощный инструмент, но у него есть свои подводные камни. Первая проблема - неправильное использование Value(). Многие разработчики используют его как глобальное хранилище данных, что приводит к неявным зависимостям и усложняет тестирование:
| Go | 1
2
3
4
5
6
7
8
9
10
11
| // Антипаттерн
func processRequest(ctx context.Context) error {
// Неявная зависимость от контекста
userID := ctx.Value("userID").(string)
return doSomething(userID)
}
// Лучше явно передавать параметры
func processRequest(ctx context.Context, userID string) error {
return doSomething(userID)
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| // Плохо
type Service struct {
ctx context.Context
// ...
}
// Хорошо
type Service struct {
// Только конфигурация
}
func (s *Service) Process(ctx context.Context) error {
// Контекст для конкретной операции
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
| func simpleWorker(stop chan struct{}) {
for {
select {
case <-stop:
return
default:
// Работа
}
}
} |
|
Context не подходит для долгоживущих объектов и глобального состояния. Вместо этого лучше использовать специализированные решения:
| Go | 1
2
3
4
5
6
7
8
9
| // Вместо контекста для конфигурации
type Config struct {
Timeout time.Duration
MaxRetries int
}
type Service struct {
config Config
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
| func retryOperation(parentCtx context.Context) error {
for i := 0; i < 3; i++ {
// Новый контекст для каждой попытки
ctx, cancel := context.WithTimeout(parentCtx, time.Second)
err := doSomething(ctx)
cancel()
if err == nil {
return nil
}
}
return errors.New("все попытки неудачны")
} |
|
| Go | 1
2
3
4
5
6
7
8
9
| type RequestContext struct {
UserID string
TraceID string
Features map[string]bool
}
func ProcessRequest(ctx context.Context, rc RequestContext) error {
// Явная передача данных
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| func (s *Service) ComplexOperation(ctx context.Context) error {
// Создаём список операций для отката
var rollbacks []func()
// При выходе проверяем необходимость отката
defer func() {
if ctx.Err() != nil {
for i := len(rollbacks) - 1; i >= 0; i-- {
rollbacks[i]()
}
}
}()
// Выполняем операции с возможностью отката
return nil
} |
|
Web сервис на Golang + martini
Добрый день, уважаемые форумчани. Есть у кого готовые исходники разработанного Web сервиса или информация как таковой разработать. Требование 1.... Golang пройтись по массиву в шаблоне
код go:
func TakeToRepair(w http.ResponseWriter, rnd render.Render) {
// rnd.HTML(200, "take_to_repair", nil)
type Table_view struct {
... Golang postgres проверить если запрос не вернул записей
Есть такой код:
func ModelLoginAuth(id, pwd string) (*MedReg) { //Cписок мед регистраторов
rows := db.Select(`SELECT fam, left(name,1),... Golang Modbus TCP Server
Здравствуйте. Подскажите как реализовать модбас сервер. нашел в интернете примеры, но вот не пойму как обратиться в адресам памяти и считать и... Golang - WiringPi на Orange pi zero
Здравствуйте. пытаюсь по работать с портами ввода вывода на orange pi, но не получается установить библиотеку https://github.com/hugozhu/rpi.... Файловый веб-сервер на golang
собственно вот пример простой, работает хорошо
package main;
import (
"http"
"fmt"
)
func requestHandler(w http.ResponseWriter, r... Как в Golang изменить символ в строке?
Я пытался заменить символ в строке, как это делается в С++, получил ошибку cannot assign to str Mogodb+golang
Добрый день
В базе хранится название, контент, дата
Задача вырвать часть контента, к примеру, первые 20 символов
... Golang GTK постоянное обновление label
Здравствуйте. подскажите как обновлять label. есть вариант вызвать таймер и обновлять метку. может есть какие нибудь другие стандартные средства ? Golang soap client
Доброе время суток, уважаемые форумчане!
Подскажите пожалуйста, кто нибудь разрабатывал клиент для работы с протоколом SOAP.
Есть... Golang + revel. Неправильные imports при генерации
Здравствуйте. При revel run ревел генерирует файлик, где сам же указывает неправильные пути в импорте
ошибка:
The Go code app/tmp/main.go does... Пакеты и их использование в Golang
Как правильно использовать пакеты в Go?
Например, есть пакет computation
package computation
func Factorial(n int) int {
var...
|
