详解Golang如何监听某个函数的开始执行和执行结束

package main

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

type Transit struct {
    worker       func(ctx context.Context, a ...any) (any, error)
    chanStarted  chan struct{}
    chanFinished chan struct{}
}

func (t *Transit) Run(ctx context.Context, a ...any) (any, error) {
    defer func() {
        t.chanFinished <- struct{}{}
    }()
    t.chanStarted <- struct{}{}
    return t.worker(ctx, a...)
}

func worker(ctx context.Context, a ...any) (any, error) {
    if timer, ok := a[0].(int); ok && timer > 0 {
        time.Sleep(time.Duration(timer) * time.Second)
    }
    return a[0], nil
}

func NewTransit() *Transit {
    return &Transit{
        worker:       worker,
        chanStarted:  make(chan struct{}),
        chanFinished: make(chan struct{}),
    }
}

func main() {
    transit := NewTransit()
    chanStarted := transit.chanStarted
    chanFinished := transit.chanFinished
    finished := make(chan struct{})
    go func() {
        for {
            select {
            case <-chanStarted:
                fmt.Println(time.Now(), "started.")
            case <-chanFinished:
                fmt.Println(time.Now(), "finished,")
                finished <- struct{}{}
                return
            default:
            }
        }
    }()
    run, _ := transit.Run(context.Background(), 0)
    <-finished
    fmt.Println(time.Now(), "result:", run)
}

package main

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

type Transit struct {
    muListener sync.RWMutex
    listener   []TransitEventInterface

    worker func(ctx context.Context, a ...any) (any, error)
}

func (t *Transit) NotifyStarted() {
    for _, l := range t.listener {
        if l == nil {
            continue
        }
        l.NotifyStarted()
    }
}

func (t *Transit) NotifyFinished() {
    for _, l := range t.listener {
        if l == nil {
            continue
        }
        l.NotifyFinished()
    }
}

type TransitEventInterface interface {
    NotifyStarted()
    NotifyFinished()
}

type TransitEventListener struct {
    TransitEventInterface
}

var notifiedStarted = make(chan struct{})
var notifiedFinished = make(chan struct{})

func (l *TransitEventListener) NotifyStarted() {
    notifiedStarted <- struct{}{}
}

func (l *TransitEventListener) NotifyFinished() {
    notifiedFinished <- struct{}{}
}

func (t *Transit) Run(ctx context.Context, a ...any) (any, error) {
    t.muListener.RLock()
    defer t.muListener.RUnlock()
    t.NotifyStarted()
    defer t.NotifyFinished()
    return t.worker(ctx, a...)
}

func worker(ctx context.Context, a ...any) (any, error) {
    if timer, ok := a[0].(int); ok && timer > 0 {
        time.Sleep(time.Duration(timer) * time.Second)
    }
    return a[0], nil
}

func NewTransit() *Transit {
    return &Transit{
        worker:   worker,
        listener: []TransitEventInterface{&TransitEventListener{}},
    }
}

func main() {
    transit := NewTransit()
    finished := make(chan struct{})
    startedTime := time.Now()
    finishedTime := time.Now()
    go func() {
        for {
            select {
            case <-notifiedStarted:
                startedTime = time.Now()
            case <-notifiedFinished:
                finishedTime = time.Now()
                finished <- struct{}{}
                return
            default:
            }
        }
    }()
    run, _ := transit.Run(context.Background(), 0)
    <-finished
    fmt.Println(time.Now(), "result:", run)
    fmt.Println(finishedTime.Sub(startedTime))
}