Go Sync 包

package main

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

func fetchPage(url string, wg *sync.WaitGroup) {
	defer wg.Done()

	fmt.Printf("开始抓取: %s\n", url)
	time.Sleep(200 * time.Millisecond) // 模拟网络请求
	fmt.Printf("完成抓取: %s\n", url)
}

func main() {
	urls := []string{
		"https://example.com",
		"https://golang.org",
		"https://github.com",
	}

	var wg sync.WaitGroup

	for _, url := range urls {
		wg.Add(1)
		go fetchPage(url, &wg)
	}

	wg.Wait()
	fmt.Println("所有页面抓取完成")
}

package main

import (
	"fmt"
	"sync"
)

// SafeCounter 使用 Mutex 保护计数器
type SafeCounter struct {
	mu    sync.Mutex
	count int
}

func (c *SafeCounter) Increment() {
	c.mu.Lock()
	defer c.mu.Unlock() // 确保 Unlock 一定被调用
	c.count++
}

func (c *SafeCounter) Get() int {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.count
}

func main() {
	counter := &SafeCounter{}
	var wg sync.WaitGroup

	// 启动 1000 个 goroutine 并发递增
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			counter.Increment()
		}()
	}

	wg.Wait()
	fmt.Printf("最终计数: %d\n", counter.Get()) // 1000
}

package main

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

var (
	instance *Config
	once     sync.Once
)

type Config struct {
	DatabaseURL string
	APIKey      string
}

func GetConfig() *Config {
	once.Do(func() {
		fmt.Println("初始化配置（只执行一次）...")
		time.Sleep(100 * time.Millisecond) // 模拟初始化
		instance = &Config{
			DatabaseURL: "postgres://localhost:5432/mydb",
			APIKey:      "sk-xxxx",
		}
	})
	return instance
}

func main() {
	var wg sync.WaitGroup

	// 10 个 goroutine 同时请求配置
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			cfg := GetConfig()
			fmt.Printf("Goroutine %d 获取配置: %s\n", id, cfg.DatabaseURL)
		}(i)
	}

	wg.Wait()
	fmt.Println("所有 goroutine 获取到相同的配置实例")
}

package main

import (
	"fmt"
	"sync"
)

func main() {
	var m sync.Map

	// 存储
	m.Store("name", "张三")
	m.Store("age", 28)
	m.Store("city", "北京")

	// 读取
	if val, ok := m.Load("name"); ok {
		fmt.Printf("name = %v\n", val)
	}

	// LoadOrStore：不存在时存储，存在时返回已有值
	actual, loaded := m.LoadOrStore("name", "李四")
	fmt.Printf("name = %v, 是否已有: %v\n", actual, loaded)

	// LoadAndDelete：读取并删除
	val, deleted := m.LoadAndDelete("city")
	fmt.Printf("删除 city = %v, 是否成功: %v\n", val, deleted)

	// 遍历
	fmt.Println("\n所有键值对:")
	m.Range(func(key, value interface{}) bool {
		fmt.Printf("  %v = %v\n", key, value)
		return true // 返回 false 停止遍历
	})

	// 并发安全示例
	var wg sync.WaitGroup
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func(n int) {
			defer wg.Done()
			key := fmt.Sprintf("key-%d", n%10) // 10 个不同的键
			m.Store(key, n)
		}(i)
	}
	wg.Wait()
	fmt.Println("\n并发写入完成")
}

package main

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

func main() {
	var counter int64
	var wg sync.WaitGroup

	// 原子递增
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			atomic.AddInt64(&counter, 1)
		}()
	}
	wg.Wait()
	fmt.Printf("原子计数: %d\n", atomic.LoadInt64(&counter)) // 1000

	// 原子存储和加载
	var status int64
	atomic.StoreInt64(&status, 1)
	fmt.Printf("状态: %d\n", atomic.LoadInt64(&status))

	// CompareAndSwap（CAS）
	var enabled int64 = 0
	swapped := atomic.CompareAndSwapInt64(&enabled, 0, 1)
	fmt.Printf("CAS 成功: %v, 新值: %d\n", swapped, enabled)

	// CAS 失败的情况
	swapped2 := atomic.CompareAndSwapInt64(&enabled, 0, 2) // 当前值是 1，不是 0
	fmt.Printf("CAS 失败: %v, 值不变: %d\n", swapped2, enabled)

	// 使用 atomic.Value 存储任意类型
	var config atomic.Value
	config.Store(map[string]string{"env": "production"})

	cfg := config.Load().(map[string]string)
	fmt.Printf("配置: %v\n", cfg)
}