package main

import (
	"fmt"
	"sync"
)

func worker(id int, sem chan struct{}) {
	sem <- struct{}{} // 占用一個(gè)信號(hào)量
	defer func() {
		<-sem // 方法運(yùn)行結(jié)束釋放信號(hào)量
	}()

	// 執(zhí)行工作任務(wù)
	fmt.Printf("Worker %d: Working...\n", id)
}

func main() {
	concurrency := 3
	sem := make(chan struct{}, concurrency)
	var wg sync.WaitGroup

	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			worker(id, sem)
		}(i)
	}

	wg.Wait()
	close(sem)
}

package main

import (
	"fmt"
	"sync"
)

func worker(id int, jobs <-chan int, results chan<- int) {
	//jobs等待主要協(xié)程往jobs放數(shù)據(jù)
	for j := range jobs {
		fmt.Printf("協(xié)程池 %d: 協(xié)程池正在工作 %d\n", id, j)
		results <- j
	}
}

func main() {
	const numJobs = 5    //協(xié)程要做的工作數(shù)量
	const numWorkers = 3 //協(xié)程池?cái)?shù)量

	jobs := make(chan int, numJobs)
	results := make(chan int, numJobs)

	var wg sync.WaitGroup

	// 啟動(dòng)協(xié)程池
	for i := 1; i <= numWorkers; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			worker(id, jobs, results)
		}(i)
	}

	// 提交任務(wù)
	for j := 1; j <= numJobs; j++ {
		jobs <- j
	}

	close(jobs)

	// 等待所有工作完成
	go func() {
		wg.Wait()
		close(results)
	}()

	// 處理結(jié)果
	for result := range results {
		fmt.Println("Result:", result)
	}
}

package main

import (
	"context"
	"fmt"
	"golang.org/x/sync/semaphore"
	"sync"
	"time"
)

func main() {
	/*
		1、在并發(fā)量一定的情況下，通過改變?cè)试S并發(fā)請(qǐng)求數(shù)可以更快處理請(qǐng)求任務(wù)(在CPU夠用的前提下)
		2、sem := semaphore.NewWeighted(n)，參數(shù)n就是權(quán)重量
		3、當(dāng)一個(gè)協(xié)程需要獲取的單位的權(quán)重越多，運(yùn)行就會(huì)慢(比如權(quán)重總量n=5個(gè)，一個(gè)協(xié)程分配了2個(gè)，跟一個(gè)協(xié)程分配1個(gè)效率是不一樣的)
		4、信號(hào)量沒有足夠的可用權(quán)重的情況發(fā)生在所有已分配的權(quán)重單位都已經(jīng)被占用，即信號(hào)量的當(dāng)前權(quán)重計(jì)數(shù)達(dá)到了它的總?cè)萘?。在這種情況下，任何嘗試通過Acquire方法獲取更多權(quán)重的調(diào)用都將無法立即完成，從而導(dǎo)致調(diào)用者（通常是goroutine）阻塞，直到其他調(diào)用者釋放一些權(quán)重單位。
	*/
	/*
		1、權(quán)權(quán)重較大的任務(wù)在資源競(jìng)爭(zhēng)時(shí)有更高的優(yōu)先級(jí)，更容易獲得執(zhí)行的機(jī)會(huì)
		2、如果當(dāng)前資源足夠滿足高權(quán)重任務(wù)的需求，這些任務(wù)將立即執(zhí)行；若資源不足，則按照權(quán)重高低順序排隊(duì)等待
		3、一旦任務(wù)開始執(zhí)行，其完成的速度主要取決于任務(wù)自身的邏輯復(fù)雜度、所需資源以及系統(tǒng)的當(dāng)前負(fù)載等因素，與任務(wù)在信號(hào)量中的權(quán)重?zé)o關(guān)
		3、高權(quán)重的任務(wù)并不會(huì)中斷已經(jīng)在執(zhí)行的低權(quán)重任務(wù)，而是等待這些任務(wù)自行釋放資源。一旦資源釋放，等待隊(duì)列中的高權(quán)重任務(wù)將優(yōu)先被喚醒
		4、Acquire 方法會(huì)檢查當(dāng)前信號(hào)量的可用資源量是否滿足請(qǐng)求的權(quán)重，如果滿足，則立即減少信號(hào)量的資源計(jì)數(shù)并返回，允許任務(wù)繼續(xù)執(zhí)行。如果不滿足，任務(wù)將阻塞等待，直到有足夠的資源被釋放
	*/
	// 記錄開始時(shí)間
	startTime := time.Now()
	// 假設(shè)外部API允許的最大并發(fā)請(qǐng)求為5(信號(hào)量的總?cè)萘渴?個(gè)權(quán)重單位)
	const (
		maxConcurrentRequests = 5
	)
	sem := semaphore.NewWeighted(maxConcurrentRequests)

	var wg sync.WaitGroup

	// 模擬對(duì)外部API的10個(gè)并發(fā)請(qǐng)求
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(requestId int) {
			defer wg.Done()
			// 假設(shè)我們想要獲取2個(gè)單位的權(quán)重
			if err := sem.Acquire(context.Background(), 2); err != nil {
				fmt.Printf("請(qǐng)求 %d 無法獲取信號(hào)量: %v\n", requestId, err)
				return
			}
			defer sem.Release(2) // 請(qǐng)求完成后釋放信號(hào)量

			// 模擬對(duì)API的請(qǐng)求處理
			fmt.Printf("請(qǐng)求 %d 開始...\n", requestId)
			time.Sleep(2 * time.Second) // 模擬網(wǎng)絡(luò)延遲
			fmt.Printf("請(qǐng)求 %d 完成。\n", requestId)
		}(i)
	}
	wg.Wait()
	// 記錄結(jié)束時(shí)間
	endTime := time.Now()
	// 計(jì)算并打印總耗時(shí)
	fmt.Printf("程序總耗時(shí): %v\n", endTime.Sub(startTime))
}

package main

import (
	"fmt"
	"golang.org/x/net/context"
	"golang.org/x/sync/semaphore"
	"runtime"
	"sync"
	"time"
)

// VideoTranscodeJob 視頻轉(zhuǎn)碼任務(wù)
type VideoTranscodeJob struct {
	resolution string
	weight     int64
}

func main() {
	cpuCount := runtime.NumCPU()
	fmt.Printf("當(dāng)前CPU個(gè)數(shù)%v\n", cpuCount)
	/*
		1、權(quán)權(quán)重較大的任務(wù)在資源競(jìng)爭(zhēng)時(shí)有更高的優(yōu)先級(jí)，更容易獲得執(zhí)行的機(jī)會(huì)
		2、如果當(dāng)前資源足夠滿足高權(quán)重任務(wù)的需求，這些任務(wù)將立即執(zhí)行；若資源不足，則按照權(quán)重高低順序排隊(duì)等待
		3、一旦任務(wù)開始執(zhí)行，其完成的速度主要取決于任務(wù)自身的邏輯復(fù)雜度、所需資源以及系統(tǒng)的當(dāng)前負(fù)載等因素，與任務(wù)在信號(hào)量中的權(quán)重?zé)o關(guān)
		3、高權(quán)重的任務(wù)并不會(huì)中斷已經(jīng)在執(zhí)行的低權(quán)重任務(wù)，而是等待這些任務(wù)自行釋放資源。一旦資源釋放，等待隊(duì)列中的高權(quán)重任務(wù)將優(yōu)先被喚醒
		4、Acquire 方法會(huì)檢查當(dāng)前信號(hào)量的可用資源量是否滿足請(qǐng)求的權(quán)重，如果滿足，則立即減少信號(hào)量的資源計(jì)數(shù)并返回，允許任務(wù)繼續(xù)執(zhí)行。如果不滿足，任務(wù)將阻塞等待，直到有足夠的資源被釋放
	*/
	// 初始化兩個(gè)信號(hào)量，一個(gè)用于標(biāo)清，一個(gè)用于高清，假設(shè)總共有8個(gè)CPU核心可用
	normalSem := semaphore.NewWeighted(6)  // 標(biāo)清任務(wù)，分配6個(gè)單位權(quán)重，因?yàn)樗鼈兿馁Y源較少
	highDefSem := semaphore.NewWeighted(2) // 高清任務(wù)，分配2個(gè)單位權(quán)重，因?yàn)樗鼈兏馁Y源

	var wg sync.WaitGroup

	//假設(shè)有20個(gè)需要轉(zhuǎn)碼的視頻
	videoJobs := []VideoTranscodeJob{
		{"HD", 2}, {"HD", 2}, {"SD", 1}, {"SD", 1}, {"HD", 2},
		{"SD", 1}, {"SD", 1}, {"HD", 2}, {"SD", 1}, {"HD", 2},
		{"SD", 4}, {"SD", 4}, {"HD", 2}, {"SD", 1}, {"HD", 2},
		{"SD", 1}, {"SD", 4}, {"HD", 2}, {"SD", 6}, {"HD", 2},
	}

	for _, job := range videoJobs {
		wg.Add(1)
		go func(job VideoTranscodeJob) {
			defer wg.Done()

			var sem *semaphore.Weighted
			switch job.resolution {
			case "SD":
				sem = normalSem //分配權(quán)重大，當(dāng)前為6，任務(wù)在獲取執(zhí)行機(jī)會(huì)上有優(yōu)勢(shì)，但并不直接意味著執(zhí)行速度快
			case "HD":
				sem = highDefSem
			default:
				panic("無效的分辨率")
			}

			if err := sem.Acquire(context.Background(), job.weight); err != nil {
				fmt.Printf("名為 %s 視頻無法獲取信號(hào)量: %v\n", job.resolution, err)
				return
			}
			defer sem.Release(job.weight) //釋放權(quán)重對(duì)應(yīng)的信號(hào)量

			// 模擬轉(zhuǎn)碼任務(wù)執(zhí)行
			fmt.Printf("轉(zhuǎn)碼 %s 視頻 (權(quán)重: %d)...\n", job.resolution, job.weight)
			//通過利用VideoTranscodeJob的weight值來模擬轉(zhuǎn)碼時(shí)間的長(zhǎng)短，HD用時(shí)長(zhǎng)則設(shè)置2比SD的1大，*時(shí)間就自然長(zhǎng)，運(yùn)行就時(shí)間長(zhǎng)
			time.Sleep(time.Duration(job.weight*100) * time.Millisecond) // 模擬不同分辨率視頻轉(zhuǎn)碼所需時(shí)間
			fmt.Printf("------------------------%s 視頻轉(zhuǎn)碼完成。。。\n", job.resolution)
		}(job)
	}
	wg.Wait()
}

package main

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

	"golang.org/x/sync/semaphore"
)

type weightedTask struct {
	id     int
	weight int64
}

func main() {
	const (
		maxTotalWeight = 20 // 最大總權(quán)重
	)
	sem := semaphore.NewWeighted(maxTotalWeight)

	var wg sync.WaitGroup
	tasksCh := make(chan weightedTask, 10)

	// 發(fā)送任務(wù)
	for i := 1; i <= 10; i++ {
		tasksCh <- weightedTask{id: i, weight: int64(i)} // 假設(shè)任務(wù)ID即為其權(quán)重
	}

	close(tasksCh)

	// 啟動(dòng)任務(wù)處理器
	for task := range tasksCh {
		wg.Add(1)
		go func(task weightedTask) {
			defer wg.Done()

			if err := sem.Acquire(context.Background(), int64(task.id)); err != nil {
				fmt.Printf("任務(wù) %d 無法獲取信號(hào)量: %v\n", task.id, err)
				return
			}
			defer sem.Release(int64(task.id)) //釋放

			// 模擬任務(wù)執(zhí)行
			fmt.Printf("任務(wù) %d (權(quán)重: %d) 正在運(yùn)行...\n", task.id, task.weight)
			time.Sleep(time.Duration(task.weight*100) * time.Millisecond) // 示例中簡(jiǎn)單用時(shí)間模擬權(quán)重影響
			fmt.Printf("任務(wù) %d 完成.\n", task.id)
		}(task)
	}
	wg.Wait()
}