golang中为什么要有context，context常见的用法

    package main

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

    func main() {
        ctx, cancel := context.WithCancel(context.Background())
        go func() {
            time.Sleep(3 * time.Second)
            cancel()
        }()

        select {
        case <-time.After(5 * time.Second):
            fmt.Println("Done")
        case <-ctx.Done():
            fmt.Println("Context was canceled:", ctx.Err())
        }
    }

// 导入Go语言的包，用于程序的运行。
package main

import (
    "context" // 用于处理并发的包，提供取消操作和超时处理。
    "fmt"      // 用于格式化I/O操作的包。
    "os"       // 用于操作系统功能接口的包。
    "os/signal" // 用于监听操作系统信号的包。
    "sync"     // 用于同步原语的包，如互斥锁。
    "time"     // 用于时间相关操作的包。
)

// FileStatus 定义文件处理的状态结构，包含名称和描述。
type FileStatus struct {
    Name        string
    Description string
}

// 定义文件处理状态常量，初始化为不同的状态和描述。
var (
    StatusNotStarted FileStatus = FileStatus{Name: "NotStarted", Description: "未被处理"}
    StatusProcessing FileStatus = FileStatus{Name: "Processing", Description: "处理中"}
    StatusCanceled   FileStatus = FileStatus{Name: "Canceled", Description: "已取消"}
    StatusCompleted  FileStatus = FileStatus{Name: "Completed", Description: "处理成功"}
)

// FileContext 结构体用于维护文件的上下文信息，包括文件ID、用户ID、状态和互斥锁。
type FileContext struct {
    FileID string      // 文件的唯一标识符。
    UserID string      // 用户的ID。
    Status *FileStatus // 当前文件的状态。
    mutex  sync.Mutex  // 互斥锁，用于同步状态更新。
}

// updateFileStatus 函数用于安全地更新文件状态，通过互斥锁确保线程安全。
func updateFileStatus(fileCtx *FileContext, newStatus *FileStatus) {
    fileCtx.mutex.Lock() // 锁定互斥锁。
    fileCtx.Status = newStatus // 更新状态。
    fileCtx.mutex.Unlock() // 解锁互斥锁。
}

// printStatusLoop 函数是一个循环，用于定期打印文件的状态信息。
func printStatusLoop(fileCtx *FileContext, exitChan chan struct{}) {
    ticker := time.NewTicker(1 * time.Second) // 创建一个定时器，每秒触发一次。
    defer ticker.Stop() // 确保在函数结束时停止定时器。

    for {
       select {
       case <-ticker.C: // 等待定时器触发。
          fileCtx.mutex.Lock() // 锁定互斥锁。
          fmt.Printf("用户%s 正在处理文件 %s... 当前状态: %s\n", fileCtx.UserID, fileCtx.FileID, fileCtx.Status.Description) // 打印状态信息。
          fileCtx.mutex.Unlock() // 解锁互斥锁。
       case <-exitChan: // 等待退出信号。
          return // 退出循环。
       }
    }
}

// processFile 函数模拟文件处理任务，接受context用于控制任务取消，FileContext保存文件状态，exitChan用于通知状态打印循环退出。
func processFile(ctx context.Context, fileCtx *FileContext, exitChan chan struct{}) {
    fmt.Printf("用户%s 的文件 %s 开始处理... 当前状态: %s\n", fileCtx.UserID, fileCtx.FileID, fileCtx.Status.Description) // 打印开始处理信息。
    // 更新状态为正在处理，并打印初始状态。
    updateFileStatus(fileCtx, &StatusProcessing)

    // 启动一个goroutine来定期打印状态信息。
    go func() {
       for {
          select {
          case <-ctx.Done(): // 等待context通知完成或取消。
             return // 退出goroutine。
          default:
             fileCtx.mutex.Lock() // 锁定互斥锁。
             fmt.Printf("用户%s 正在处理文件 %s... 当前状态: %s\n", fileCtx.UserID, fileCtx.FileID, fileCtx.Status.Description) // 打印状态信息。
             fileCtx.mutex.Unlock() // 解锁互斥锁。
          }
          time.Sleep(1 * time.Second) // 休眠一秒。
       }
    }()

    // 模拟文件处理逻辑，10秒后自动完成。
    select {
    case <-ctx.Done(): // 等待context通知。
       if ctx.Err() == context.Canceled { // 检查是否被取消。
          updateFileStatus(fileCtx, &StatusCanceled) // 更新状态为已取消。
          fmt.Printf("用户%s 的文件 %s 被取消。\n", fileCtx.UserID, fileCtx.FileID) // 打印取消信息。
       }
       close(exitChan) // 任务完成或取消，关闭exitChan。
       return // 退出函数。
    case <-time.After(5 * time.Second): // 等待5秒。
       updateFileStatus(fileCtx, &StatusCompleted) // 更新状态为处理成功。
       fmt.Printf("用户%s 的文件 %s 处理成功。\n", fileCtx.UserID, fileCtx.FileID) // 打印成功信息。
       close(exitChan) // 任务完成，关闭exitChan。
    }
}

func main() {
    // 创建文件上下文，初始化文件ID、用户ID和状态。
    fileCtx := &FileContext{
       FileID: "file_789",
       UserID: "123456",
       Status: &StatusNotStarted,
       mutex:  sync.Mutex{},
    }

    // 创建退出通道，用于通知其他goroutine退出。
    exitChan := make(chan struct{})
    defer close(exitChan) // 确保在main结束前关闭退出通道。

    // 创建一个可以取消的context，用于控制文件处理任务的取消。
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel() // 确保在main结束前取消context。

    // 捕捉中断信号，用于处理用户中断操作，如Ctrl+C。
    signalChan := make(chan os.Signal, 1)
    signal.Notify(signalChan, os.Interrupt, os.Kill)

    // 启动一个goroutine来监听中断信号，并在接收到信号时调用cancel函数。
    go func() {
       sig := <-signalChan // 阻塞等待接收到信号。
       fmt.Println("接收到中断信号:", sig)
       cancel()        // 调用cancel来取消context。
       close(exitChan) // 关闭退出通道，通知其他goroutine退出。
    }()

    // 启动文件处理任务，作为goroutine运行。
    go processFile(ctx, fileCtx, exitChan)

    // 打印状态信息的循环可以在这里启动，如果需要的话。
    // 例如：
    // go printStatusLoop(fileCtx, exitChan)

    // 等待文件处理任务完成或被取消。
    select {
    case <-ctx.Done():
       // 此处不需要额外处理，因为processFile已经处理了状态更新。
    case <-exitChan:
       // 状态打印goroutine已经停止。
    }

    // 打印最终状态，通过锁定互斥锁保证线程安全。
    fileCtx.mutex.Lock()
    fmt.Printf("文件处理最终状态：%s\n", fileCtx.Status.Description)
    fileCtx.mutex.Unlock()

    // 清理，移除信号监听。
    signal.Stop(signalChan)

    // 正常退出程序。
    os.Exit(0)
}