Golang 并发编程基础

是个小胖墩儿啊

已于 2023-09-04 18:00:59 修改

阅读量777

点赞数

分类专栏： Golang 文章标签： golang

于 2023-08-18 11:03:56 首次发布

本文链接：https://blog.csdn.net/qq_43665821/article/details/132357029

版权

Golang 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

runtime 包，定义了协程管理相关的 API

runtime.Gosched()

package main

import (
	"fmt"
	"runtime"
)

func main() {
	go func() {
		for i := 0; i <= 5; i++ {
			fmt.Println(i)
		}
	}()

	// 让出当前CPU给其他协程
	runtime.Gosched()
	fmt.Println("end...")
}

runtime.Goexit()

package main

import (
	"fmt"
	"runtime"
	"time"
)

func show() {
	for i := 0; i <= 5; i++ {
		if i > 3 {
			// 退出当前协程
			runtime.Goexit()
		}
		fmt.Println(i)
	}
}

func main() {
	go show()
	// 主协程睡眠1s
	time.Sleep(time.Second)
	fmt.Println("end...")
}

runtime.GOMAXPROCS()

package main

import (
	"fmt"
	"runtime"
	"time"
)

func funcA() {
	for i := 0; i < 5; i++ {
		fmt.Printf("funcA: %v \n", i)
		time.Sleep(time.Millisecond * 100)
	}
}

func funcB() {
	for i := 0; i < 5; i++ {
		fmt.Printf("funcB: %v \n", i)
		time.Sleep(time.Millisecond * 100)
	}
}

func main() {
	fmt.Printf("CPU nums: %v \n", runtime.NumCPU())

	// 设置最大CPU核心数
	runtime.GOMAXPROCS(1)
	go funcA()
	go funcB()

	// 主协程睡眠1s
	time.Sleep(time.Second)
	fmt.Println("end...")
}

Mutex 互斥锁实现同步

sync.Mutex

package main

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

var count int
var wp sync.WaitGroup
var lock sync.Mutex

func add() {
	defer wp.Done()
	// 加锁
	lock.Lock()
	count++
	fmt.Printf("add: %v \n", count)
	time.Sleep(time.Millisecond * 10)
	// 解锁
	lock.Unlock()
}

func sub() {
	defer wp.Done()
	lock.Lock()
	count--
	fmt.Printf("sub: %v \n", count)
	time.Sleep(time.Millisecond * 100)
	lock.Unlock()
}

func main() {
	for i := 0; i < 10; i++ {
		wp.Add(1)
		go add()
		wp.Add(1)
		go sub()
	}

	// 等待子协程执行完再执行主协程
	wp.Wait()
	fmt.Printf("count: %v \n", count)
	fmt.Println("end...")
}

进程、线程、协程

进程（Process）：进程是操作系统中的一个执行实体，代表一个程序的运行实例。每个进程都有自己的独立内存空间和系统资源，如文件、网络连接等。进程间是相互独立的，通过操作系统进行资源分配和调度。进程之间的通信需要使用特定的通信机制，如管道、信号量等
线程（Thread）：线程是进程中的一个执行流，也被称为轻量级进程。一个进程可以创建多个线程，它们共享进程的内存空间和系统资源。线程之间切换的开销相对较小，因为它们共享了大部分上下文和资源。多线程可以实现并发执行，提高程序的效率和响应性。但线程之间的共享资源需要注意同步和互斥的问题，以避免竞态条件和死锁等并发问题
协程（Coroutine）：协程是一种用户级的轻量级线程，也被称为协作式多任务。与线程不同，协程的调度是由用户代码来控制的，而不是由操作系统进行调度。在协程中，任务的切换是协作式的，即一个任务让出 CPU 给其他任务执行。协程通常具有低开销和高效率的特点，适合于处理大量的并发任务和高度并发的网络编程

总结起来，进程是系统资源分配和调度的独立单位，线程是 CPU 资源分配和调度的基本单位，协程是一种用户级的轻量级线程，通过用户代码进行调度。它们在实现并发和多任务处理方面具有不同的特点和应用场景。