浅谈Go用于同步和并发控制的几种常见锁

package main

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

// 定义一个共享资源
var counter int = 0

// 创建一个互斥锁
var lock sync.Mutex

func main() {
	// 创建一个等待组，以便等待所有goroutine完成
	var wg sync.WaitGroup

	// 启动多个goroutine来增加计数器
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			for j := 0; j < 10; j++ {
				// 在修改共享资源前获取锁
				lock.Lock()
				// 修改共享资源
				counter++
				fmt.Printf("Goroutine %d sees counter: %d\n", id, counter)
				// 释放锁
				lock.Unlock()
				// 等待一段时间，模拟处理过程
				time.Sleep(time.Millisecond * 10)
			}
		}(i)
	}

	// 等待所有goroutine完成
	wg.Wait()

	// 打印最终的计数器值
	fmt.Println("Final counter:", counter)
}

package main

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

// 定义一个共享资源
var data int = 0

// 创建一个读写互斥锁
var rwMutex sync.RWMutex

func main() {
	// 创建一个等待组，以便等待所有goroutine完成
	var wg sync.WaitGroup

	// 启动多个读goroutine
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			readData(id)
		}(i)
	}

	// 启动多个写goroutine
	for i := 0; i < 2; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			writeData(id)
		}(i)
	}

	// 等待所有goroutine完成
	wg.Wait()
}

// 读取数据的函数
func readData(id int) {
	for j := 0; j < 5; j++ {
		// 获取读锁
		rwMutex.RLock()
		fmt.Printf("Goroutine %d reads data: %d\n", id, data)
		// 释放读锁
		rwMutex.RUnlock()
		// 等待一段时间，模拟读取过程
		time.Sleep(time.Millisecond * 100)
	}
}

// 写入数据的函数
func writeData(id int) {
	for j := 0; j < 5; j++ {
		// 获取写锁
		rwMutex.Lock()
		// 修改数据
		data += id
		fmt.Printf("Goroutine %d writes data: %d\n", id, data)
		// 释放写锁
		rwMutex.Unlock()
		// 等待一段时间，模拟写入过程
		time.Sleep(time.Millisecond * 100)
	}
}

package main

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

// 缓冲区容量
const bufferSize = 5

// 缓冲区
var buffer = make([]int, 0, bufferSize)

// 互斥锁
var mutex sync.Mutex

// 条件变量
var cond = sync.NewCond(&mutex)

func main() {
	// 创建一个等待组，以便等待所有goroutine完成
	var wg sync.WaitGroup

	// 启动生产者goroutine
	for i := 0; i < 2; i++ {
		wg.Add(1)
		go producer(&wg, i)
	}

	// 启动消费者goroutine
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go consumer(&wg, i)
	}

	// 等待所有goroutine完成
	wg.Wait()
}

// 生产者函数
func producer(wg *sync.WaitGroup, id int) {
	defer wg.Done()
	for j := 0; j < 10; j++ {
		time.Sleep(time.Millisecond * 100) // 模拟生产过程

		// 获取锁
		mutex.Lock()
		// 等待缓冲区未满
		for len(buffer) == bufferSize {
			cond.Wait()
		}
		// 生产数据
		buffer = append(buffer, j)
		fmt.Printf("Producer %d produced: %d, buffer: %v\n", id, j, buffer)
		// 唤醒消费者
		cond.Signal()
		// 释放锁
		mutex.Unlock()
	}
}

// 消费者函数
func consumer(wg *sync.WaitGroup, id int) {
	defer wg.Done()
	for {
		time.Sleep(time.Millisecond * 150) // 模拟消费过程

		// 获取锁
		mutex.Lock()
		// 等待缓冲区非空
		for len(buffer) == 0 {
			cond.Wait()
		}
		// 消费数据
		data := buffer[0]
		buffer = buffer[1:]
		fmt.Printf("Consumer %d consumed: %d, buffer: %v\n", id, data, buffer)
		// 唤醒生产者
		cond.Signal()
		// 释放锁
		mutex.Unlock()
	}
}

package main

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

// 定义一个全局变量用于存放初始化资源
var resource string

// 定义一个sync.Once变量
var once sync.Once

// 模拟资源初始化的函数
func initialize() {
	fmt.Println("Initializing resource...")
	resource = "Resource Initialized"
}

func main() {
	// 创建一个等待组，以便等待所有goroutine完成
	var wg sync.WaitGroup

	// 启动多个goroutine，尝试初始化资源
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			useResource(id)
		}(i)
	}

	// 等待所有goroutine完成
	wg.Wait()

	// 最后打印资源的状态
	fmt.Println("Final resource state:", resource)
}

// 使用资源的函数，尝试初始化资源
func useResource(id int) {
	// 使用sync.Once的Do方法确保initialize函数只执行一次
	once.Do(initialize)
	fmt.Printf("Goroutine %d using resource: %s\n", id, resource)
	// 模拟资源使用过程
	time.Sleep(time.Millisecond * 100)
}

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

func main() {
	var wg sync.WaitGroup
	var count int32 = 0

	// 启动多个goroutine来增加计数器
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for j := 0; j < 5; j++ {
				// 使用atomic.AddInt32来原子地增加计数器
				atomic.AddInt32(&count, 1)
			}
		}()
	}

	// 等待所有goroutine完成
	wg.Wait()

	// 使用atomic.LoadInt32来原子地读取计数器
	finalCount := atomic.LoadInt32(&count)
	fmt.Println("Final count:", finalCount)

	// 尝试使用atomic.CompareAndSwapInt32来条件性地更新计数器
	if atomic.CompareAndSwapInt32(&count, finalCount, 100) {
		fmt.Println("Count was", finalCount, ", updated count to 100")
	} else {
		fmt.Println("Failed to update count")
	}

	// 再次读取并打印计数器的值
	updatedCount := atomic.LoadInt32(&count)
	fmt.Println("Updated count:", updatedCount)
}

package main

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

// 定义一个结构体类型，用于示例
type MyObject struct {
	ID int
}

// 创建一个全局的sync.Pool对象
var objectPool = sync.Pool{
	New: func() interface{} {
		return &MyObject{}
	},
}

func main() {
	var wg sync.WaitGroup

	// 启动多个goroutine来获取和放回对象
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()

			// 从对象池中获取一个对象
			obj := objectPool.Get().(*MyObject)

			// 模拟对象的使用
			obj.ID = id
			fmt.Printf("Goroutine %d using object with ID: %d\n", id, obj.ID)

			// 模拟工作延迟
			time.Sleep(time.Millisecond * 100)

			// 重置对象的状态（可选）
			obj.ID = 0

			// 将对象放回池中
			objectPool.Put(obj)
		}(i)
	}

	// 等待所有goroutine完成
	wg.Wait()

	// 打印对象池的状态
	fmt.Println("All goroutines finished, objects are back in the pool.")
}