Go语言并发编程

Go语言并发编程

一、线程等待

type WaitGroup结构体（Add、Done、Wait）：

package main

import (
	"fmt"
	"sync"
)

func mainWait() {
	for i := 1; i < 10; i++ {
		fmt.Println("main:", i)
	}
}
func TestWait(wg *sync.WaitGroup) {
	defer wg.Done() //减少信号次数
	for i := 1; i < 100; i++ {
		fmt.Println("Route:", i)
	}
}
func main() {
	var wg sync.WaitGroup //设置信号量
	wg.Add(1)             //加上信号次数（次数用完Wait方法阻塞等待的所有线程都会释放）
	go TestWait(&wg)//这里一定要传指针，不然无法修改wg的值，线程一直等待会死锁
	mainWait()
	wg.Wait() //等待信号结束
}

注：Wait和Add要在例程外面，Done在例程里面，不然容易直接结束线程等待

二、互斥锁

背景：多个例程对同一数据进行操作，需要加锁，类似Redis线程锁

type Mutex结构体（Lock,Unlock）

package main

import (
	"fmt"
	"sync"
)

func main() {
	var a int = 2000
	var b int = 2000
	var wg sync.WaitGroup
	var locker sync.Mutex   //定义锁变量
	wg.Add(2)
	go func() {
		locker.Lock()   //加锁
		a = a + 1000
		b = b - 1000
		wg.Done()
		locker.Unlock()   //解锁，可以使用defer，但是需要匿名函数
	}()
	go func() {
		locker.Lock()
		a = a - 1000
		b = b + 1000
		wg.Done()
		locker.Unlock()
	}()
	wg.Wait()
	fmt.Printf("总共为:%d", a+b)
}

三、sync/atomic原子性操作

1、底层加锁原理；

2、具体怎么使用查看官方文档；

3、看为一个整体操作

四、管道

具体知识前往Go语言基础管道，下面只讲解部分知识点

1、无缓冲区管道读写

写和读的操作必须成对，不然会进行阻塞

package main

import (
	"fmt"
	"time"
)

func main() {
	ch := make(chan struct{})
	go func() {
		time.Sleep(5 * time.Second) //设置等待，5s后才能写入
		ch <- struct{}{}            //空结构体可以节约内存
	}()
	<-ch //主线程阻塞，一直等待线程写入后读取
	fmt.Println("end")
}

2、关闭管道

管道关闭后无法继续写入

	close(ch)                   //关闭管道
	ch <- 1
Panic错误（可以恢复的错误）：
    panic: send on closed channel

3、阻塞发生情况

阻塞和死锁不同，死锁是没人写，阻塞是读写不同步

4、监听管道

package main

import (
	"fmt"
	"time"
)

func main() {
	var ch1 chan struct{} = make(chan struct{})
	var ch2 chan struct{} = make(chan struct{})
	go func() {
		time.Sleep(4 * time.Second)
		ch1 <- struct{}{}
	}()
	go func() {
		time.Sleep(3 * time.Second)
		ch2 <- struct{}{}
	}()
	select {
	case <-ch1:
		fmt.Println("This is ch1")
	case <-ch2:
		fmt.Println("This is ch2")
	}
}

实例，main函数超过5秒就输出超时，没5秒就输出

第二种方法：

package main

import (
	"fmt"
	_ "fmt"
	"time"
)

func main() {
	res := make(chan time.Time)
	go func() {
		time.Sleep(6 * time.Second)
		res <- time.Now()
	}()
	select {
	case <-res:
		fmt.Println("任务成功")
	case <-time.After(5 * time.Second):
		fmt.Println("已经超时")
	}
}

五、读写锁

作用;并发的修改同一文件数据（读取数据不用），因为互斥锁会把所有操作都锁起来，包括读的操作，会导致效率下降，所以出现了读写锁。

	//读写锁
	//获取锁 Lock Rlock
	//释放锁 Unlock Runlock
	//写写互斥，写读互斥，读读不互斥（Rlock,Rlock）
package main

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

func main() {
	var wg sync.WaitGroup
	var locker sync.RWMutex
	wg.Add(2)
	go func() {
		fmt.Println("A before")
		locker.RLock()
		fmt.Println("A Do")
		time.Sleep(10 * time.Second)
		locker.RUnlock()
		fmt.Println("A After")
		wg.Done()
	}()
	go func() {
		time.Sleep(time.Second * 1)
		fmt.Println("B before")
		locker.RLock()
		fmt.Println("B Do")
		locker.RUnlock()
		fmt.Println("B After")
		wg.Done()
	}()
	wg.Wait()
}

六、Cond锁

//type Cond 对象的使用（）

package main

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

func main() {
	var locker sync.Mutex
	var wg sync.WaitGroup
	wg.Add(2)
	cond := sync.NewCond(&locker) //创建cond结构体指针
	go func() {
		cond.L.Lock()
		cond.Wait()   //起到了阻塞作用
		fmt.Println("我得到信号了")
		wg.Done()
		cond.L.Unlock()

	}()
	go func() {
		time.Sleep(time.Second * 5)
		wg.Done()
		cond.Broadcast()
	}()
	wg.Wait()
}

七、Once

八、Pool对象

没有就直接创建池对象，有就直接用

package main

import (
	"fmt"
	_ "fmt"
	"sync"
)

type student struct {
	id int
}

func main() {
	index := 0
	pool := sync.Pool{
		New: func() interface{} {
			index++
			stu := student{
				id: index,
			}
			return &stu
		},
	}
	c := pool.Get()
	fmt.Println(c) //pool中创建c
	c1 := pool.Get()
	fmt.Println(c1)  //pool中创建c1
	pool.Put(c1)     //把c1放回去
	c2 := pool.Get() //再拿的时候pool中有c1,所以直接取c1
	fmt.Println(c2)
}

九、Runtime

Gosched调度获取

package main

import (
	"fmt"
	_ "fmt"
	"runtime"
	"sync"
)

func main() {
	runtime.Gosched() // 让出CPU时间 time.Sleep()

	// var wg *sync.WaitGroup
	wg := new(sync.WaitGroup)

	for i := 0; i < 2; i++ {
		wg.Add(1)
		go func(i int) {
			for ch := 'A'; ch < 'Z'; ch++ {
				fmt.Printf("%d: %c\n", i, ch)
				runtime.Gosched()
			}
			wg.Done()
		}(i)
	}

	wg.Wait()
}

如果看完对自己有所帮助，请点赞支持。谢谢大家