package main

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

// 定義一個(gè)共享資源
var counter int = 0

// 創(chuàng)建一個(gè)互斥鎖
var lock sync.Mutex

func main() {
	// 創(chuàng)建一個(gè)等待組，以便等待所有g(shù)oroutine完成
	var wg sync.WaitGroup

	// 啟動多個(gè)goroutine來增加計(jì)數(shù)器
	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()
				// 等待一段時(shí)間，模擬處理過程
				time.Sleep(time.Millisecond * 10)
			}
		}(i)
	}

	// 等待所有g(shù)oroutine完成
	wg.Wait()

	// 打印最終的計(jì)數(shù)器值
	fmt.Println("Final counter:", counter)
}

package main

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

// 定義一個(gè)共享資源
var data int = 0

// 創(chuàng)建一個(gè)讀寫互斥鎖
var rwMutex sync.RWMutex

func main() {
	// 創(chuàng)建一個(gè)等待組，以便等待所有g(shù)oroutine完成
	var wg sync.WaitGroup

	// 啟動多個(gè)讀goroutine
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			readData(id)
		}(i)
	}

	// 啟動多個(gè)寫goroutine
	for i := 0; i < 2; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			writeData(id)
		}(i)
	}

	// 等待所有g(shù)oroutine完成
	wg.Wait()
}

// 讀取數(shù)據(jù)的函數(shù)
func readData(id int) {
	for j := 0; j < 5; j++ {
		// 獲取讀鎖
		rwMutex.RLock()
		fmt.Printf("Goroutine %d reads data: %d\n", id, data)
		// 釋放讀鎖
		rwMutex.RUnlock()
		// 等待一段時(shí)間，模擬讀取過程
		time.Sleep(time.Millisecond * 100)
	}
}

// 寫入數(shù)據(jù)的函數(shù)
func writeData(id int) {
	for j := 0; j < 5; j++ {
		// 獲取寫鎖
		rwMutex.Lock()
		// 修改數(shù)據(jù)
		data += id
		fmt.Printf("Goroutine %d writes data: %d\n", id, data)
		// 釋放寫鎖
		rwMutex.Unlock()
		// 等待一段時(shí)間，模擬寫入過程
		time.Sleep(time.Millisecond * 100)
	}
}

package main

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

// 緩沖區(qū)容量
const bufferSize = 5

// 緩沖區(qū)
var buffer = make([]int, 0, bufferSize)

// 互斥鎖
var mutex sync.Mutex

// 條件變量
var cond = sync.NewCond(&mutex)

func main() {
	// 創(chuàng)建一個(gè)等待組，以便等待所有g(shù)oroutine完成
	var wg sync.WaitGroup

	// 啟動生產(chǎn)者goroutine
	for i := 0; i < 2; i++ {
		wg.Add(1)
		go producer(&wg, i)
	}

	// 啟動消費(fèi)者goroutine
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go consumer(&wg, i)
	}

	// 等待所有g(shù)oroutine完成
	wg.Wait()
}

// 生產(chǎn)者函數(shù)
func producer(wg *sync.WaitGroup, id int) {
	defer wg.Done()
	for j := 0; j < 10; j++ {
		time.Sleep(time.Millisecond * 100) // 模擬生產(chǎn)過程

		// 獲取鎖
		mutex.Lock()
		// 等待緩沖區(qū)未滿
		for len(buffer) == bufferSize {
			cond.Wait()
		}
		// 生產(chǎn)數(shù)據(jù)
		buffer = append(buffer, j)
		fmt.Printf("Producer %d produced: %d, buffer: %v\n", id, j, buffer)
		// 喚醒消費(fèi)者
		cond.Signal()
		// 釋放鎖
		mutex.Unlock()
	}
}

// 消費(fèi)者函數(shù)
func consumer(wg *sync.WaitGroup, id int) {
	defer wg.Done()
	for {
		time.Sleep(time.Millisecond * 150) // 模擬消費(fèi)過程

		// 獲取鎖
		mutex.Lock()
		// 等待緩沖區(qū)非空
		for len(buffer) == 0 {
			cond.Wait()
		}
		// 消費(fèi)數(shù)據(jù)
		data := buffer[0]
		buffer = buffer[1:]
		fmt.Printf("Consumer %d consumed: %d, buffer: %v\n", id, data, buffer)
		// 喚醒生產(chǎn)者
		cond.Signal()
		// 釋放鎖
		mutex.Unlock()
	}
}

package main

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

// 定義一個(gè)全局變量用于存放初始化資源
var resource string

// 定義一個(gè)sync.Once變量
var once sync.Once

// 模擬資源初始化的函數(shù)
func initialize() {
	fmt.Println("Initializing resource...")
	resource = "Resource Initialized"
}

func main() {
	// 創(chuàng)建一個(gè)等待組，以便等待所有g(shù)oroutine完成
	var wg sync.WaitGroup

	// 啟動多個(gè)goroutine，嘗試初始化資源
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			useResource(id)
		}(i)
	}

	// 等待所有g(shù)oroutine完成
	wg.Wait()

	// 最后打印資源的狀態(tài)
	fmt.Println("Final resource state:", resource)
}

// 使用資源的函數(shù)，嘗試初始化資源
func useResource(id int) {
	// 使用sync.Once的Do方法確保initialize函數(shù)只執(zhí)行一次
	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

	// 啟動多個(gè)goroutine來增加計(jì)數(shù)器
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for j := 0; j < 5; j++ {
				// 使用atomic.AddInt32來原子地增加計(jì)數(shù)器
				atomic.AddInt32(&count, 1)
			}
		}()
	}

	// 等待所有g(shù)oroutine完成
	wg.Wait()

	// 使用atomic.LoadInt32來原子地讀取計(jì)數(shù)器
	finalCount := atomic.LoadInt32(&count)
	fmt.Println("Final count:", finalCount)

	// 嘗試使用atomic.CompareAndSwapInt32來?xiàng)l件性地更新計(jì)數(shù)器
	if atomic.CompareAndSwapInt32(&count, finalCount, 100) {
		fmt.Println("Count was", finalCount, ", updated count to 100")
	} else {
		fmt.Println("Failed to update count")
	}

	// 再次讀取并打印計(jì)數(shù)器的值
	updatedCount := atomic.LoadInt32(&count)
	fmt.Println("Updated count:", updatedCount)
}

package main

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

// 定義一個(gè)結(jié)構(gòu)體類型，用于示例
type MyObject struct {
	ID int
}

// 創(chuàng)建一個(gè)全局的sync.Pool對象
var objectPool = sync.Pool{
	New: func() interface{} {
		return &MyObject{}
	},
}

func main() {
	var wg sync.WaitGroup

	// 啟動多個(gè)goroutine來獲取和放回對象
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()

			// 從對象池中獲取一個(gè)對象
			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)

			// 重置對象的狀態(tài)（可選）
			obj.ID = 0

			// 將對象放回池中
			objectPool.Put(obj)
		}(i)
	}

	// 等待所有g(shù)oroutine完成
	wg.Wait()

	// 打印對象池的狀態(tài)
	fmt.Println("All goroutines finished, objects are back in the pool.")
}