package main

import (

	"fmt"

	"time"

)

func main() {

	/*

	临界资源：

	 */

	a := 1

	go func() {

		a = 2

		fmt.Println("goroutine中。。",a)

	}()

	a = 3

	time.Sleep(1)

	fmt.Println("main goroutine...",a) //2

}

package main

import (

	"fmt"

	"sync" //同步包

)

//同步等待组中有counter计数器，初始值为零

var wg sync.WaitGroup //创建同步等待组的对象

func main() {

	/*

	WaitGroup：同步等待组

		Add()，设置等待组中要执行的子 goroutine的数量

		Wait()，让主goroutine处于等待

		Done()，让等待组中的counter计数器的值减1，同Add(-1)

	 */

	wg.Add(2)

	//注意：如果counter为3，但是只有两个子goroutine被抓进来，

	//counter的值只被减了两次1，最终值为1

	//会报死锁的panic

	go fun1() //子goroutine被加载到同步等待组中

	go fun2() //子goroutine被加载到同步等待组中

	fmt.Println("main 进入阻塞状态。。等待wg中的子goroutien结束。。")

	wg.Wait() // 表示main goroutine进入等待，意味着阻塞

	//计数器值为零是，解除阻塞

	fmt.Println("main..解除阻塞。。")

}

func fun1() {

	for i := 1; i < 10; i++ {

		fmt.Println("fun1()函数中打印。。A ", i)

	}

	wg.Done() //给wg等待组中的counter数值减1。同	wg.Add(-1)

}

func fun2() {

	defer wg.Done()

	for j := 1; j < 10; j++ {

		fmt.Println("\tfun2()函数打印。。", j)

	}

}

package main

import (

	"fmt"

	"time"

	"math/rand"

	"sync"

)

//全局变量，表示票

var ticket = 100 //100张票

var mutex sync.Mutex //创建锁头

var wg sync.WaitGroup //同步等待组对象

func main() {

	/*

	4个goroutine，模拟4个售票口

	在使用互斥锁的时候，对资源操作完，一定要解锁。否则会出现程序异常，死锁等问题。

	建议使用defer语句解锁

	 */

	wg.Add(4)

	go saleTickets("售票口1")

	go saleTickets("售票口2")

	go saleTickets("售票口3")

	go saleTickets("售票口4")

	wg.Wait() //main要等待

	fmt.Println("程序结束了。。。")

}

func saleTickets(name string) {

	rand.Seed(time.Now().UnixNano())

	defer wg.Done()

	for {

		//上锁

		mutex.Lock()

		if ticket > 0 {

			//一个子goroutine开始卖票，睡觉，醒来，卖票（这张票已经被另一个g卖掉了，但是还会继续卖）

			//time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)

			time.Sleep(10* time.Millisecond) //阻塞才会切换协程，否则就是窗口1卖完了

			fmt.Println(name, "售出：", ticket)

			ticket--

		} else {

			mutex.Unlock() //条件不满足，也要解锁，否则break后，就执行不到解锁

			fmt.Println(name, "售罄，没有票了。。")

			break

		}

		mutex.Unlock() //解锁

	}

}

 1、可以随便读，多个goroutine同时读。

 ​

 2、写的时候，啥也不能干。不能读也不能写。

package main

import (

	"fmt"

	"sync"

	"time"

)

var rwMutex *sync.RWMutex

//为了保证子的goroutine先执行，可以使用同步等待组

var wg *sync.WaitGroup

func main() {

	rwMutex = new(sync.RWMutex)

	wg = new(sync.WaitGroup)

	//wg.Add(2)

	//多个同时读取

	//go readData(1)

	//go readData(2)

	wg.Add(3)

	go writeData(1)

	go readData(2)

	go writeData(3)

	wg.Wait()

	fmt.Println("main..over...")

}

func writeData(i int) {

	defer wg.Done()

	fmt.Println(i, "开始写：write start。。")

	rwMutex.Lock() //写操作上锁

	fmt.Println(i, "正在写：writing。。。。")

	time.Sleep(3 * time.Second)

	rwMutex.Unlock()

	fmt.Println(i, "写结束：write over。。")

}

func readData(i int) {

	defer wg.Done()

	fmt.Println(i, "开始读：read start。。")

	rwMutex.RLock() //读操作上锁

	fmt.Println(i, "正在读取数据：reading。。。")

	time.Sleep(3 * time.Second) //写的操作是互斥的，能够感觉到这个睡眠时间

	rwMutex.RUnlock() //读操作解锁

	fmt.Println(i, "读结束：read over。。。")

}