Go 언어의 동기화 메커니즘은 무엇입니까?

Go 동기화 메커니즘에는 다음이 포함됩니다. 1. 동시성 문제의 데이터 흐름에 초점을 맞춘 채널. 흐르는 데이터를 채널에 넣으면 채널을 사용하여 동시성을 해결할 수 있습니다. 잠금 및 잠금 해제 주요 구현 아이디어는 3. Sync.waitGroup 5. Sync.context 7. 변수에서 작동합니다.

이 튜토리얼의 운영 환경: Windows 7 시스템, GO 버전 1.18, Dell G3 컴퓨터.

Golang에서 제공하는 동기화 메커니즘에는 동기화 모듈 아래의 Mutex 및 WaitGroup과 언어 자체에서 제공하는 chan이 포함됩니다.

1.channel

Overview

Golang은 다음과 같은 분명한 방식으로 우리에게 말합니다. .

장점: 채널의 핵심은 동시성 문제에서 데이터 흐름에 주의를 기울이고 채널을 사용하여 이 동시성

문제를 해결할 수 있습니다. 채널은 스레드로부터 안전하며 데이터 충돌이 없으므로 잠금보다 사용하기가 훨씬 쉽습니다

단점: 여러 코루틴의 동기화 대기 문제와 같이 동기화가 너무 복잡한 시나리오에는 적합하지 않습니다. 교착 상태 문제가 있습니다, 채널 교착 상태 문제: 교착 상태 문제 링크

분류

채널 유형: 버퍼링되지 않은 유형과 버퍼링된 유형
두 가지 형태의 채널이 있는데, 하나는 스레드가 메시지를 보낸 후 버퍼링되지 않은 채널입니다. 채널을 사용하면 스레드가 이 채널에서 메시지를 수신하기 위해 다른 스레드를 알고 있는 현재 채널을 차단합니다. 버퍼링되지 않은 형태는 다음과 같습니다.

intChan := make(chan int)
 
带缓冲的channel，是可以指定缓冲的消息数量，当消息数量小于指定值时，不会出现阻塞，超过之后才会阻塞，需要等待其他线程去接收channel处理，带缓冲的形式如下：
 
//3为缓冲数量
intChan := make(chan int， 3)

Example

 type Person struct {
	Name    string
	Age     uint8
	Address Addr
}
 
type Addr struct {
	city     string
	district string
}
 
/*
测试channel传输复杂的Struct数据
 */
func testTranslateStruct() {
	personChan := make(chan Person, 1)
 
	person := Person{"xiaoming", 10, Addr{"shenzhen", "longgang"}}
	personChan <- person
 
	person.Address = Addr{"guangzhou", "huadu"}
	fmt.Printf("src person : %+v \n", person)
 
	newPerson := <-personChan
	fmt.Printf("new person : %+v \n", newPerson)
}

실제 신청 과정에서는 채널 종료 신호를 기다리는 과정이 무한정일 수 없습니다. 일반적으로 타이머가 동반됩니다.

/*
检查channel读写超时，并做超时的处理
 */
func testTimeout() {
	g := make(chan int)
	quit := make(chan bool)
 
	go func() {
		for {
			select {
			case v := <-g:
				fmt.Println(v)
			case <-time.After(time.Second * time.Duration(3)):
				quit <- true
				fmt.Println("超时，通知主线程退出")
				return
			}
		}
	}()
 
	for i := 0; i < 3; i++ {
		g <- i
	}
 
	<-quit
	fmt.Println("收到退出通知，主线程退出")
}

2.Sync.Mutex

Mutex에는 Lock과 Unlock의 두 가지 방법이 있습니다. 주요 구현 아이디어는 Lock 기능에 반영됩니다.

Lock이 실행되면 세 가지 상황이 발생합니다.

• 충돌 없음, CAS 작업을 통해 현재 상태가 잠금 상태로 설정됩니다.

• 충돌이 발생하여 회전을 시작하고 잠금이 해제될 때까지 기다립니다. 이 섹션에 다른 고루틴이 있으면 잠금이 해제되고, 해제되지 않으면 3을 입력합니다. 충돌이 발생하여 스핀 단계가 통과되었습니다. 현재 고루틴은 semacquire 함수를 호출하여 대기 상태로 들어갑니다.

• 충돌이 없는 경우가 가장 간단한 경우입니다. 충돌이 있는 경우 효율성을 위해 스핀이 먼저 수행됩니다. 왜냐하면 Mutex로 보호되는 대부분의 코드 세그먼트는 매우 짧고 짧은 스핀 후에 얻을 수 있기 때문입니다. ; 회전 대기가 실패하면 현재 고루틴은 세마포어를 기다려야 합니다.

3. Sync.waitGroup

Channel은 다음과 같이 여러 채널을 사용하든 채널 배열을 사용하든 일부 동기화 시나리오에서 사용하기가 약간 복잡합니다.

func coordinateWithChan() {
 sign := make(chan struct{}, 2)
 num := int32(0)
 fmt.Printf("The number: %d [with chan struct{}]\n", num)
 max := int32(10)
 go addNum(&num, 1, max, func() {
  sign <- struct{}{}
 })
 go addNum(&num, 2, max, func() {
  sign <- struct{}{}
 })
 <-sign
 <-sign
}

그래서 Sync.waitGroup은 더 우아합니다. 고루틴 그룹이 끝날 때까지 기다립니다. 메인 고루틴에서 선언되고 대기할 고루틴 수를 설정합니다. 각 고루틴이 실행된 후 Done이 호출되고 마지막으로 메인 고루틴에서 대기합니다. JAVA의 CountDownLatch 또는 루프 장벽과 유사하며 Sync.waitGroup은 다음 API를 제공하여 재사용할 수 있습니다.

func (wg *WaitGroup) Add(delta int)
func (wg *WaitGroup) Done()
func (wg *WaitGroup) Wait()

그러나 Sync.waitGroup을 사용하려면 패닉이 발생하는 것을 방지하기 위해 몇 가지 규칙을 따라야 합니다.

a. , waitGroup의 내부 카운트 값이 음수로 표시됩니다

b. WaitGroup의 내부 카운트 값이 0에 도달하면 Add 메소드가 호출되어 깨워야 할 고루틴이 깨어나지 않게 됩니다. 그리고 새로운 하나의 계산 주기가 시작됩니다

따라서 호출할 때 다음 원칙을 따라야 합니다.

먼저 통합 추가, 다음 동시 완료, 마지막으로 대기

Sync.Once

Sync. .once는 내부적으로 구현됩니다. 메서드가 실행되었는지 확인하는 데 사용되는 int32비트 플래그를 포함합니다. 플래그 값이 변경되는 시점은 메서드가 실행된 이후입니다. 먼저, 동기화가 이루어지지 않은 경우, 플래그 값이 0인 경우 뮤텍스 잠금을 획득하기 위해 경쟁하고 이때 플래그 값을 판단하게 됩니다. 메소드가 실제로 한 번 실행되는지 확인합니다. 첫 번째 재확인은 빠른 판단을 위한 것이지만, 두 번째 확인은 이때 플래그 값의 상태를 정확하게 판단하기 위한 것입니다. use :

func main() {
    var once sync.Once
    onceBody := func() {
        time.Sleep(3e9)
        fmt.Println("Only once")
    }
    done := make(chan bool)
    for i := 0; i < 10; i++ {
        j := i
        go func(int) {
            once.Do(onceBody)
            fmt.Println(j)
            done <- true
        }(j)
    }
    //给一部分时间保证能够输出完整【方法一】
    //for i := 0; i < 10; i++ {
    //    <-done
    //}

    //给一部分时间保证能够输出完整【方法二】
    <-done
    time.Sleep(3e9)
}

5. Context

scenario

여러 배치의 컴퓨팅 작업 또는 일대일 협업 프로세스가 필요할 때

a.如何生成自己的context

 通过WithCancel、WithDeadline、WithTimeout和WithValue四个方法从context.Background中派生出自己的子context

 注意context.background这个上下文根节点仅仅是一个最基本的支点，它不提供任何额外的功能，也就是说，它既不可以被撤销（cancel），也不能携带任何数据,在使用是必须通过以上4种方法派生出自己的context

b.子context是会继承父context的值

c.撤销消息的传播

撤销消息会按照深度遍历的方式传播给子context（注意因为多routine调用的原因，最终的撤销顺序可能不会是深度遍历的顺序）

，在遍历的过程中，通过WithCancel、WithDeadline、WithTimeout派生的context会被撤销，但是通过WithValue方法派生的context不会被撤销

6. Sync.pool

7.atomic包，针对变量进行操作

    我们调用sync/atomic中的几个函数可以对几种简单的类型进行原子操作。这些类型包括int32,int64,uint32,uint64,uintptr,unsafe.Pointer,共6个。这些函数的原子操作共有5种：增或减，比较并交换、载入、存储和交换它们提供了不同的功能，切使用的场景也有区别。

增或减

　　 顾名思义，原子增或减即可实现对被操作值的增大或减少。因此该操作只能操作数值类型。

　　 被用于进行增或减的原子操作都是以“Add”为前缀，并后面跟针对具体类型的名称。

//方法源码
func AddUint32(addr *uint32, delta uint32) (new uint32)

增

栗子：（在原来的基础上加n）

atomic.AddUint32(&addr,n)

减

栗子：(在原来的基础上加n（n为负数))

atomic.AddUint32(*addr,uint32(int32(n)))
//或
atomic.AddUint32(&addr,^uint32(-n-1))

比较并交换

　　 比较并交换----Compare And Swap 简称CAS

　　 他是假设被操作的值未曾被改变（即与旧值相等），并一旦确定这个假设的真实性就立即进行值替换

　　 如果想安全的并发一些类型的值，我们总是应该优先使用CAS

//方法源码
func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)

栗子：（如果addr和old相同,就用new代替addr）

ok:=atomic.CompareAndSwapInt32(&addr,old,new)

载入

　　 如果一个写操作未完成，有一个读操作就已经发生了，这样读操作使很糟糕的。

　　 为了原子的读取某个值sync/atomic代码包同样为我们提供了一系列的函数。这些函数都以"Load"为前缀，意为载入。

//方法源码
func LoadInt32(addr *int32) (val int32)

栗子

fun addValue(delta int32){
    for{
        v:=atomic.LoadInt32(&addr)
        if atomic.CompareAndSwapInt32(&v,addr,(delta+v)){
            break;
        }
    }
}

存储

　　 与读操作对应的是写入操作，sync/atomic也提供了与原子的值载入函数相对应的原子的值存储函数。这些函数的名称均以“Store”为前缀

　　 在原子的存储某个值的过程中，任何cpu都不会进行针对进行同一个值的读或写操作。如果我们把所有针对此值的写操作都改为原子操作，那么就不会出现针对此值的读操作读操作因被并发的进行而读到修改了一半的情况。

　　 原子操作总会成功，因为他不必关心被操作值的旧值是什么。

//方法源码
func StoreInt32(addr *int32, val int32)

栗子

atomic.StoreInt32(被操作值的指针,新值)
atomic.StoreInt32(&value,newaddr)

交换

　　 原子交换操作，这类函数的名称都以“Swap”为前缀。

　　 与CAS不同，交换操作直接赋予新值，不管旧值。

　　 会返回旧值

//方法源码
func SwapInt32(addr *int32, new int32) (old int32)

栗子

atomic.SwapInt32(被操作值的指针,新值)（返回旧值）
oldval：=atomic.StoreInt32(&value,newaddr)

扩展知识：Sync包简述

1. 什么是Sync包？

Package sync provides basic synchronization primitives such as mutual exclusion locks. Other than the Once and WaitGroup types, most are intended for use by low-level library routines. Higher-level synchronization is better done via channels and communication.

Values containing the types defined in this package should not be copied.

这句话大意是说：
Sync包同步提供基本的同步原语，如互斥锁。 除了Once和WaitGroup类型之外，大多数类型都是供低级库例程使用的。 通过Channel和沟通可以更好地完成更高级别的同步。并且此包中的值在使用过后不要拷贝。

从描述中可以看到的是，golang 并不推荐这个包中的大多数并发控制方法，但还是提供了相关方法，主要原因是golang中提倡以共享内存的方式来通信:

不要以共享内存的方式来通信，作为替代，我们应该以通信的手段来共享内存

共享内存的方式使得多线程中的通信变得简单，但是在并发的安全性控制上将变得异常繁琐。
正确性不是我们唯一想要的，我们想要的还有系统的可伸缩性，以及可理解性，我觉得这点非常重要，比如现在广泛使用的Raft算法。

2. 包中的Type

包中主要有: Locker, Cond, Map, Mutex, Once, Pool,
RWMutex, WaitGroup

type Locker interface {
        Lock()
        Unlock()
}
type Cond struct {
        // L is held while observing or changing the condition
        L Locker
}

3. 什么是锁，为什么需要锁？

锁是sync包中的核心，他主要有两个方法，加锁和解锁。
在单线程运行的时候程序是顺序执行的，程序对数据的访问也是:
读取 => 一顿操作(加减乘除之类的) => 写回原地址
但是一旦程序中进行了并发编程，也就是说，某一个函数可能同时被不同的线程执行的时候，以时间为维度会发生以下情况：

可以看到的是，A地址的数字被执行了两次自增，若A=5，我们在执行完成后预期的A值是7，但是在这种情况下我们得到的A却是6，bug了~
还有很多类似的并发错误，所以才有锁的引入。若是我们在线程2读取A的值的时候对A进行加锁，让线程2等待，线程1执行完成之后在执行线程2，这样就能够保证数据的正确性。但是正确性不是我们唯一想要的。

4 写更优雅的代码

在很多语言中我们经常为了保证数据安全正确，会在并发的时候对数据加锁

Lock()
doSomething()
Unlock()

Golang在此包中也提供了相关的锁，但是标明了"most are intended for use by low-level library routines" 所以我这里只对 Once and WaitGroup types做简述。

5.Once 对象

Once 是一个可以被多次调用但是只执行一次，若每次调用Do时传入参数f不同，但是只有第一个才会被执行。

func (o *Once) Do(f func())

    var once sync.Once
    onceBody := func() {
        fmt.Println("Only once")
    }
    done := make(chan bool)
    for i := 0; i < 10; i++ {
        go func() {
            once.Do(onceBody)
            done <- true
        }()
    }
    for i := 0; i < 10; i++ {
        <-done
    }

如果你执行这段代码会发现，虽然调用了10次，但是只执行了1次。BTW：这个东西可以用来写单例。

6. WaitGroup

下面是个官方的例子：

var wg sync.WaitGroup
var urls = []string{
        "http://www.golang.org/",
        "http://www.google.com/",
        "http://www.somestupidname.com/",
}
for _, url := range urls {
        // Increment the WaitGroup counter.
        wg.Add(1)
        // Launch a goroutine to fetch the URL.
        go func(url string) {
                // Decrement the counter when the goroutine completes.
                defer wg.Done()
                // Fetch the URL.
                http.Get(url)
        }(url)
}
// Wait for all HTTP fetches to complete.
wg.Wait()

7. 简述

Golang中高级的并发可以通过channel来实现，这是golang所倡导的，但是go也提供了锁等先关操作。

【相关推荐：Go视频教程、编程教学】

위 내용은 Go 언어의 동기화 메커니즘은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!