Learn to go concurrent programming in 7 days go language sync Application and implementation of cond

List of articles

Catalog

List of articles

Preface

One 、sync.Cond What is it?

Two 、sync.Cond Use

1. Sync.Cond initialization

2.Sync.Cond Easy to use

3.Sync.Cond Of BroadCast Methods use

4.Sync.Cond Of Signal() Methods use

3、 ... and 、Cond Internal principle

summary

---

---

Preface

The previous programming articles mainly introduced some principles and applications of concurrent programming , It mainly solves the problem of critical resource protection in concurrent programming 、 Communication problems between multithreads 、 Multithread execution order problem . But in actual programming , A common problem encountered is conditional execution between multiple threads . Conditional execution between multiple threads means that multiple threads are in a waiting state , After receiving the corresponding signal, execute . Take a living scene ： Many people queue up for the bus , Everyone is ready to get on the bus , But the car hasn't come yet . Only wait , Looking forward to the stars , Looking forward to the moon , Here comes the bus . When the bus comes , For people waiting in line , There will be two situations ：1、 Successfully get on the bus 2、 Because there are so many people , vehicle Refuse to carry , No seats in row . In this case , The waiting condition is on the bus , And give instructions on how many people to take on the train .

One 、sync.Cond What is it?

   sync.Cond be located sync.package The package , The main function is to provide a temporary variable . Through this temporary variable, when the waiting condition is not satisfied , Thread blocking 、 Wait until the conditions are met , The function of thread re execution . 

Two 、sync.Cond Use

1. Sync.Cond initialization

Cond During initialization , Need to pass in a Mutex Parameters of type .

package main

import "sync"

func main() {
	mutex := sync.Mutex{}
	cond := sync.NewCond(&mutex)
}

 

2.Sync.Cond Easy to use

Here is a simple implementation Cond Use , The implementation starts with go Thread waiting , Thread blocking waits until cond.BroadCast perform , To wake up the waiting thread .

package main

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

func main() {
	signal := 1
	mutex := sync.Mutex{}
	cond := sync.NewCond(&mutex)
	go func() {
		cond.L.Lock()
		for signal == 1 {
			fmt.Println(" Thread starts waiting ")
			cond.Wait()
			fmt.Println(" Thread waiting to end ")
		}
		cond.L.Unlock()
	}()
	time.Sleep(200*time.Millisecond)
	cond.Broadcast()
	signal=0
	time.Sleep(200*time.Millisecond)

}

3.Sync.Cond Of BroadCast Methods use

The following implements a BroadCast application , Realization 10 Threads blocking and waiting at the same time , Conditional variables execute BroadCase after , All threads execute concurrently . Because it uses BroadCast Methods , Wake up all waiting threads , So use waitGroup Manage batch thread execution .

package main

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

func main() {
	signal := 1
	mutex := sync.Mutex{}
	cond := sync.NewCond(&mutex)
	group := sync.WaitGroup{}
	group.Add(10)
	for i := 0; i < 10; i++ {
		go func(int1 int) {
			defer group.Done()
			cond.L.Lock()
			for signal == 1 {
				fmt.Printf(" Threads %d Start the waiting \n",int1)
				cond.Wait()
				fmt.Printf(" Threads %d end \n",int1)
			}
			cond.L.Unlock()
		}(i)
	}
	time.Sleep(200*time.Millisecond)
	cond.Broadcast()
	signal=0
	group.Wait()
}

  Corresponding execution effect ：

Threads 4 Start the waiting
Threads 9 Start the waiting
Threads 5 Start the waiting
Threads 6 Start the waiting
Threads 7 Start the waiting
Threads 8 Start the waiting
Threads 1 Start the waiting
Threads 0 Start the waiting
Threads 2 Start the waiting
Threads 3 Start the waiting
Threads 3 end
Threads 2 end
Threads 7 end
Threads 4 end
Threads 9 end
Threads 5 end
Threads 6 end
Threads 1 end
Threads 0 end
Threads 8 end

Process finished with the exit code 0
 

4.Sync.Cond Of Signal() Methods use

The following implements a BroadCast application , Realization 10 Threads blocking and waiting at the same time , Conditional variables execute Signal after , Concurrent preemption of all threads . Because it uses Signal Methods , Only one thread will be executed . The rule of choice is "first come, first served, first served" , Who will be the first to execute .

package main

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

func main() {
	signal := 1
	mutex := sync.Mutex{}
	cond := sync.NewCond(&mutex)
	c := make(chan  struct{}, 1)
	for i := 0; i < 10; i++ {
		go func(int1 int) {
			defer func() {
				c<- struct{}{}
			}()
			cond.L.Lock()
			for signal == 1 {
				fmt.Printf(" Threads %d Start the waiting \n",int1)
				cond.Wait()
				fmt.Printf(" Threads %d end \n",int1)
			}
			cond.L.Unlock()
		}(i)
	}
	time.Sleep(200*time.Millisecond)
	cond.Signal()
	signal=0
	<-c
}

Corresponding execution effect ：

  Threads 0 Start the waiting
Threads 9 Start the waiting
Threads 2 Start the waiting
Threads 3 Start the waiting
Threads 4 Start the waiting
Threads 5 Start the waiting
Threads 6 Start the waiting
Threads 7 Start the waiting
Threads 8 Start the waiting
Threads 1 Start the waiting
Threads 0 end

---

3、 ... and 、Cond Internal principle

The core source code is as follows ：

func (c *Cond) Wait() {
	c.checker.check()
	t := runtime_notifyListAdd(&c.notify)  // Add thread to wait queue 
	c.L.Unlock()
	runtime_notifyListWait(&c.notify, t) // Let the thread waiting on the queue start waiting 
	c.L.Lock()
}

summary

         That's what we're going to talk about today , This article only briefly introduces cond Use ,Cond It provides a mechanism that can realize multi-threaded cooperative execution . This mechanism has been applied to many projects , Some related content will be updated in the future .

        You are welcome to give us more valuable comments , Leave more messages and interact ~