How to use context to implement request circuit breaker in Go

How to use context to implement request circuit breaker in Go

With the popularity of microservice architecture, communication between various services has become more and more frequent. In inter-service communication, the call chain may be very long, and the failure or timeout of one request may cause the entire call chain to fail, thus affecting the availability of the entire system. In order to protect the entire system from the failure of a single service, we can use request circuit breaking to control and limit access to a certain service. This article will introduce how to use context to implement request circuit breaker in Go.

What is request circuit breaker?

Request circuit breaking is a strategy used to protect the entire system. When the request failure rate of a service exceeds a predetermined threshold, request circuit breaker will quickly deny access to the service, thereby avoiding the occurrence of cascading failures. The request breaker mode is usually used in combination with the circuit breaker mode (Circuit Breaker Pattern). When a request fails, the circuit breaker will be opened quickly, thereby rejecting requests for the service and preventing a large number of requests from piling up and causing system resource exhaustion.

The sample code for using context to implement request circuit breaker in Go is as follows:

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

type CircuitBreaker struct {
    context    context.Context
    cancel     context.CancelFunc
    maxFail    int
    fail       int
    breaker    bool
    resetTime  time.Duration
    breakerMux sync.Mutex
}

func NewCircuitBreaker(maxFail int, resetTime time.Duration) *CircuitBreaker {
    ctx, cancel := context.WithCancel(context.Background())

    circuitBreaker := &CircuitBreaker{
        context:    ctx,
        cancel:     cancel,
        maxFail:    maxFail,
        fail:       0,
        breaker:    false,
        resetTime:  resetTime,
        breakerMux: sync.Mutex{},
    }

    return circuitBreaker
}

func (c *CircuitBreaker) Do(req func() error) error {
    select {
    case <-c.context.Done():
        return fmt.Errorf("circuit breaker is open")
    default:
        if !c.breaker {
            err := req()
            if err == nil {
                c.reset()
            } else {
                c.fail++
                if c.fail >= c.maxFail {
                    c.breakerMux.Lock()
                    c.breaker = true
                    c.breakerMux.Unlock()
                    go time.AfterFunc(c.resetTime, c.reset)
                }
            }
            return err
        } else {
            return fmt.Errorf("circuit breaker is open") 
        }
    }
}

func (c *CircuitBreaker) reset() {
    c.fail = 0
    c.breakerMux.Lock()
    c.breaker = false
    c.breakerMux.Unlock()
    c.cancel()
}

func main() {
    circuitBreaker := NewCircuitBreaker(3, 2*time.Minute)

    // 进行模拟请求
    for i := 0; i < 10; i++ {
        err := circuitBreaker.Do(func() error {
            // 这里执行实际的请求操作，此处只是模拟
            fmt.Println("执行请求...")
            if i%5 == 0 {
                return fmt.Errorf("request failed")
            }
            return nil
        })

        if err != nil {
            fmt.Printf("请求失败: %v
", err)
        } else {
            fmt.Println("请求成功")
        }
    }
}

In the above sample code, we implemented a simple request circuit breaker through the CircuitBreaker structure. The CircuitBreaker structure has the following attributes:

• context and cancel: used to control the life cycle of the request breaker. After the fuse is opened, the request will be rejected.
• maxFail: Set the maximum number of failures. When the number of failures exceeds the set value, the fuse will open.
• fail: Record the number of failed requests.
• breaker: Record the status of the fuse. When true, it means the fuse is open.
• resetTime: fuse reset time. After opening the fuse, after this period of time, the fuse will be closed again.

Specific request operations can be performed through the Do method. If the request is successful, the failure count will be reset and nil will be returned. If the request fails, the failure count will be incremented, and when the failure count reaches the set value, the fuse will be opened.
It should be noted that when the fuse is opened, new requests will immediately return error information.

In the main function, we created a sample CircuitBreaker and simulated 10 requests. When the number of failures reaches the set value, the fuse will open and new requests will be rejected.

By using the context package and the custom CircuitBreaker structure, we can easily implement the request breaker function in Go. Using request circuit breaker can effectively protect the entire system from the impact of a single service failure and improve the availability and stability of the system.

The above is the detailed content of How to use context to implement request circuit breaker in Go. For more information, please follow other related articles on the PHP Chinese website!