Go 阻塞的实现示例

package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan struct{})
	go func() {
		fmt.Println("业务处理~~~")
		time.Sleep(2 * time.Second)
		fmt.Println("业务处理完成~~~")
		close(c) // 关闭channel，通知工作完成
	}()

	<-c // 阻塞等待channel关闭
	fmt.Println("处理其他业务~~~")
}

package main

import (
	"fmt"
	"strconv"
	"sync"
	"time"
)

func main() {
	var wg sync.WaitGroup //控制并发组

	doWork := func(i int) {
        // wg.Done(): 表示一个事件已经完成。它等价于 wg.Add(-1)，但更明确地表达了“完成一个任务”的意图，并且在使用上更安全，因为它不会导致计数变为负数（如果已经到达零，则会panic）。
		defer wg.Done() // 当函数返回时，通知WaitGroup一个操作已完成相当于wg.Add(-1)
		fmt.Println("处理业务~~~" + strconv.Itoa(i))
		time.Sleep(2 * time.Second)
		fmt.Println("业务处理完成~~~" + strconv.Itoa(i))
	}

	for i := 0; i < 5; i++ {
		wg.Add(1)    // 增加WaitGroup的计数器
		go doWork(i) // 启动一个goroutine做工作
	}
	//主goroutine调用wg.Wait()，直到所有启动的goroutines都通过调用wg.Done()通知它们已经完成工作
	wg.Wait() // 阻塞，直到WaitGroup的计数器为0
	fmt.Println("所有业务处理完成~~~")
}

package main

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

func main() {
	var mtx sync.Mutex         //创建互斥锁
	cond := sync.NewCond(&mtx) //使用mtx作为底层互斥锁
	ready := false

	// 启动一个 goroutine 来改变条件变量 ready 的值，并通知 cond。
	go func() {
		fmt.Println("循环跟goroutine是go内部决定先调度的--------------------goroutine--------------------")
		time.Sleep(3 * time.Second)
		mtx.Lock() //使用互斥锁
		ready = true
		cond.Signal() // 唤醒至少一个等待的 goroutine
		mtx.Unlock()  //解锁
	}()

	mtx.Lock() // 锁定互斥锁，准备进入条件等待
	for !ready {
		fmt.Println("循环跟goroutine是go内部决定先调度的--------------------阻塞--------------------")
		cond.Wait() // 阻塞，直到 cond.Signal() 被调用
		//mtx.Unlock()
	}
	mtx.Unlock() // 解锁互斥锁，继续执行（此处mtx.Unlock()在for循环里面阻塞等待完成后也可以，也可以没有，因为主线程会结束,但如果后续还需要获取互斥锁则必须要释放否则报错）

	fmt.Println("准备继续~~~")
}

package main

import "sync"

func main() {
	var wg sync.WaitGroup
	wg.Add(1)
	wg.Wait()
}

package main

func main() {
	select{}
}

package main

func main() {
	for {}
}

package main

import "sync"

func main() {
	var m sync.Mutex
	m.Lock()
}

package main

import (
	"os"
	"os/signal"
	"syscall"
)

func main() {
	sig := make(chan os.Signal, 2)
	//syscall.SIGTERM 是默认的终止进程信号，通常由服务管理器（如systemd、supervisor等）发送来请求程序正常终止。
	//syscall.SIGINT 是中断信号，一般由用户按下Ctrl+C键触发，用于请求程序中断执行
	signal.Notify(sig, syscall.SIGTERM, syscall.SIGINT)
	<-sig
}

package main

import (
	"os"
	"os/signal"
	"syscall"
	"time"
)

func main() {
	sig := make(chan os.Signal, 2)
	//syscall.SIGTERM 是默认的终止进程信号，通常由服务管理器（如systemd、supervisor等）发送来请求程序正常终止。
	//syscall.SIGINT 是中断信号，一般由用户按下Ctrl+C键触发，用于请求程序中断执行
	signal.Notify(sig, syscall.SIGTERM, syscall.SIGINT)

	go func() {
		time.Sleep(10 * time.Second)
		sig <- syscall.SIGTERM
	}()

	go func() {
		time.Sleep(5 * time.Second)
		sig <- syscall.SIGINT
	}()

	<-sig
}

package main

func main() {
	c := make(chan struct{})
	<-c
}

package main

func main() {
	var c chan struct{} //nil channel
	<-c
}