Go controls the number of concurrency of coroutines (goroutines)

package main

import (
	"fmt"
	"sync"
)

func worker(id int, sem chan struct{}) {
	sem <- struct{}{} // Takes up a semaphore	defer func() {
		<-sem // The method is running and releases the semaphore	}()

	// Perform work tasks	("Worker %d: Working...\n", id)
}

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

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

	()
	close(sem)
}

package main

import (
	"fmt"
	"sync"
)

func worker(id int, jobs <-chan int, results chan<- int) {
	//jobs wait for the main coroutine to put data into the jobs	for j := range jobs {
		("Coecess Pool %d: The coroutine pool is working %d\n", id, j)
		results <- j
	}
}

func main() {
	const numJobs = 5    //The amount of work to be done by coroutine	const numWorkers = 3 //Number of coroutine pools
	jobs := make(chan int, numJobs)
	results := make(chan int, numJobs)

	var wg 

	// Start coroutine pool	for i := 1; i <= numWorkers; i++ {
		(1)
		go func(id int) {
			defer ()
			worker(id, jobs, results)
		}(i)
	}

	// Submit task	for j := 1; j <= numJobs; j++ {
		jobs <- j
	}

	close(jobs)

	// Wait for all work to be completed	go func() {
		()
		close(results)
	}()

	// Processing results	for result := range results {
		("Result:", result)
	}
}

package main

import (
	"context"
	"fmt"
	"/x/sync/semaphore"
	"sync"
	"time"
)

func main() {
	/*
		 1. When the concurrency amount is constant, the request task can be processed faster by changing the number of concurrent requests allowed (under the premise that the CPU is sufficient)
		 2. sem := (n), parameter n is the weight
		 3. The more weights a coroutine needs to obtain, the slower it will run (for example, the total weights n=5, a coroutine allocates 2, which is different from a coroutine allocating one).
		 4. The semaphore does not have enough available weights to occur when all assigned weight units have been occupied, that is, the current weight count of the semaphore reaches its total capacity.  In this case, any call that attempts to get more weights through the Acquire method will not be completed immediately, causing the caller (usually goroutine) to block until some units of weight are released by other callers.
	 */
	/*
		 1. Tasks with higher weights have higher priority when competing for resources, making it easier to obtain execution opportunities.
		 2. If the current resources are sufficient to meet the needs of high-weight tasks, these tasks will be executed immediately; if the resources are insufficient, queue up in order of weight
		 3. Once the task starts to be executed, the speed of completion mainly depends on the task's own logical complexity, the required resources, and the current load of the system, and has nothing to do with the weight of the task in the semaphore.
		 3. High-weight tasks do not interrupt low-weight tasks that are already being executed, but wait for these tasks to release their resources themselves.  Once the resource is released, high-weight tasks in the waiting queue will be awakened first.
		 4. The Acquire method will check whether the available resources of the current semaphore meet the requested weight. If it is satisfied, the resource count of the semaphore is immediately reduced and returns, allowing the task to continue execution.  If not satisfied, the task will block and wait until enough resources are freed
	 */
	// Record the start time	startTime := ()
	// Assume that the maximum concurrent request allowed by the external API is 5 (the total capacity of the semaphore is 5 weight units)	const (
		maxConcurrentRequests = 5
	)
	sem := (maxConcurrentRequests)

	var wg 

	// Simulate 10 concurrent requests to external APIs	for i := 0; i < 10; i++ {
		(1)
		go func(requestId int) {
			defer ()
			// Suppose we want to get the weight of 2 units			if err := ((), 2); err != nil {
				("Request %d cannot get semaphore: %v\n", requestId, err)
				return
			}
			defer (2) // Release the semaphore after the request is completed
			// Simulate request processing to the API			("Request %d start...\n", requestId)
			(2 * ) // Simulate network delay			("Request %d complete.\n", requestId)
		}(i)
	}
	()
	// Record the end time	endTime := ()
	// Calculate and print the total time	("Total program time: %v\n", (startTime))
}

package main

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

// VideoTranscodeJob Video Transcoding Tasktype VideoTranscodeJob struct {
	resolution string
	weight     int64
}

func main() {
	cpuCount := ()
	("Current CPUs %v\n", cpuCount)
	/*
		 1. Tasks with higher weights have higher priority when competing for resources, making it easier to obtain execution opportunities.
		 2. If the current resources are sufficient to meet the needs of high-weight tasks, these tasks will be executed immediately; if the resources are insufficient, queue up in order of weight
		 3. Once the task starts to be executed, the speed of completion mainly depends on the task's own logical complexity, the required resources, and the current load of the system, and has nothing to do with the weight of the task in the semaphore.
		 3. High-weight tasks do not interrupt low-weight tasks that are already being executed, but wait for these tasks to release their resources themselves.  Once the resource is released, high-weight tasks in the waiting queue will be awakened first.
		 4. The Acquire method will check whether the available resources of the current semaphore meet the requested weight. If it is satisfied, the resource count of the semaphore is immediately reduced and returns, allowing the task to continue execution.  If not satisfied, the task will block and wait until enough resources are freed
	 */
	// Initialize two semaphores, one for standard definition and one for high definition, assuming a total of 8 CPU cores are available	normalSem := (6)  // Standard Definition tasks, allocate 6 units of weights because they consume less resources	highDefSem := (2) // HD tasks, allocate 2 units of weights, because they consume more resources
	var wg 

	//Suppose there are 20 videos that need to be transcoded	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 {
		(1)
		go func(job VideoTranscodeJob) {
			defer ()

			var sem *
			switch  {
			case "SD":
				sem = normalSem //The allocation weight is large, currently 6, the task has an advantage in obtaining execution opportunities, but it does not directly mean that the execution speed is fast			case "HD":
				sem = highDefSem
			default:
				panic("Invalid resolution")
			}

			if err := ((), ); err != nil {
				("The video named %s cannot obtain semaphore: %v\n", , err)
				return
			}
			defer () //Release the signal quantity corresponding to the weight
			// Simulated transcoding task execution			("Transcoding %s video (Weight: %d)...\n", , )
			//Use the weight value of VideoTranscodeJob to simulate the length of the transcoding time. The HD usage time is set to 2 more than SD 1, so the time will naturally be longer and the running time will be longer.			((*100) * ) // Time required to simulate video transcoding at different resolutions			("----------------------%s video transcoding is completed...\n", )
		}(job)
	}
	()
}

package main

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

	"/x/sync/semaphore"
)

type weightedTask struct {
	id     int
	weight int64
}

func main() {
	const (
		maxTotalWeight = 20 // Maximum total weight	)
	sem := (maxTotalWeight)

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

	// Send a task	for i := 1; i <= 10; i++ {
		tasksCh <- weightedTask{id: i, weight: int64(i)} // Assume that the task ID is its weight	}

	close(tasksCh)

	// Start the task processor	for task := range tasksCh {
		(1)
		go func(task weightedTask) {
			defer ()

			if err := ((), int64()); err != nil {
				("Task %d cannot obtain semaphore: %v\n", , err)
				return
			}
			defer (int64()) //release
			// Simulate task execution			("Task %d (Weight: %d) Running...\n", , )
			((*100) * ) // In the example, the effect of simply using time to simulate the weight			("Task %d completed.\n", )
		}(task)
	}
	()
}