先从内存中取出x的值
• CPU进行计算+1
• 然后将x+1的结果放到内存

解决线程冲突问题

• 以下代码的输出数据不是2000000

var count int

func test1(waitGroup *sync.WaitGroup) {
for i:=0;i<1000000;i++ {
count ++
}
waitGroup.Done()
}

func test2(waitGroup *sync.WaitGroup) {
for i:=0;i<1000000;i++ {
count ++
}
waitGroup.Done()
}

func main() {
var wg sync.WaitGroup
wg.Add(2)
go test1(&wg)
go test2(&wg)
wg.Wait()
fmt.Printf("count=%d\n",count)
}

互斥锁

• 同时且只有一个线程进入临界区，其他的线程则在等待锁
• 当互斥锁释放之后，等待锁的线程才可以获取锁进入临界区
• 多个线程同时等待同一个锁，唤醒的策略是随机的

修复线程问题，使其正确输出

var count int
var mutex sync.Mutex

func test1(waitGroup *sync.WaitGroup) {
for i:=0;i<1000000;i++ {
mutex.Lock()
count ++
mutex.Unlock()
}
waitGroup.Done()
}

func test2(waitGroup *sync.WaitGroup) {
for i:=0;i<1000000;i++ {
//加锁
mutex.Lock()
count ++
//解锁
mutex.Unlock()
}
waitGroup.Done()
}

func main() {
var wg sync.WaitGroup
wg.Add(2)
go test1(&wg)
go test2(&wg)
wg.Wait()
fmt.Printf("count=%d\n",count)
}

读写锁

• 使用场景： 读多写少的场景
• 分为两种角色： 读锁和写锁
• 当一个goroutine获取写锁之后，其他的goroutine获取写锁或读锁都会等待
• 当一个goroutine获取读锁之后，其他的goroutine获取写锁都会等待，但其他goroutine获取读锁时，都会继续获得锁

var rwlock sync.RWMutex
var wg sync.WaitGroup
var counter int

func writer() {
for i := 0;i<1000;i++ {
rwlock.Lock()
counter++
rwlock.Unlock()
time.Sleep(10*time.Millisecond)
}
wg.Done()
}

func reader()  {
for i:=0;i<1000;i++ {
rwlock.RLock()
fmt.Printf("counter=%d\n",counter)
time.Sleep(time.Millisecond)
rwlock.RUnlock()
}
wg.Done()
}

func main() {
wg.Add(1)
go writer()
for i:=0;i<10;i++ {
wg.Add(1)
go reader()
}
wg.Wait()
}

• 对比读写锁与互斥锁的性能

var rwlock sync.RWMutex
var wg sync.WaitGroup
var mlock sync.Mutex
var counter int

func writer() {
for i := 0;i<1000;i++ {
rwlock.Lock()
counter++
rwlock.Unlock()
time.Sleep(10*time.Millisecond)
}
wg.Done()
}

func reader()  {
for i:=0;i<1000;i++ {
rwlock.RLock()
//fmt.Printf("counter=%d\n",counter)
time.Sleep(time.Millisecond)
rwlock.RUnlock()
}
wg.Done()
}

func writer_mutex() {
for i := 0;i<1000;i++ {
mlock.Lock()
counter++
mlock.Unlock()
time.Sleep(10*time.Millisecond)
}
wg.Done()
}

func reader_mutex()  {
for i:=0;i<1000;i++ {
mlock.Lock()
//fmt.Printf("counter=%d\n",counter)
time.Sleep(time.Millisecond)
mlock.Unlock()
}
wg.Done()
}

func main() {
start := time.Now().UnixNano()
wg.Add(1)
go writer()
for i:=0;i<10;i++ {
wg.Add(1)
go reader()
}
wg.Wait()
end := time.Now().UnixNano()
cost_time := (float64(end)-float64(start))/1000/1000/1000
fmt.Printf("RWlock总耗时：%f s\n",cost_time)

start_m := time.Now().UnixNano()
wg.Add(1)
go writer_mutex()
for i:=0;i<10;i++ {
wg.Add(1)
go reader_mutex()
}
wg.Wait()
end_m := time.Now().UnixNano()
cost_time_m := (float64(end_m)-float64(start_m))/1000/1000/1000
fmt.Printf("Mutexlock总耗时：%f s\n",cost_time_m)
}

原子操作

• 计数需求，会使用到原子操作
• 加锁代价会比较耗时，需要上下文切换
• 针对基本数据类型，可以使用原子操作确保线程安全
• 原子操作在用户态就可以完成，因此性能要比互斥锁要高

var counts int32

func test3() {
for i:=0;i<1000000;i++ {
//counts ++,替换成原子加1操作
atomic.AddInt32(&counts,1)
}
}

func test4() {
for i:=0;i<1000000;i++ {
atomic.AddInt32(&counts,1)
}
}

func main() {
go test3()
go test4()
time.Sleep(time.Second)
fmt.Printf("counts=%d\n",counts)
}

练习

• 采用多线程遍历目录，然后生成缩略图
• 参考代码（单线程模式）

const DEFAULT_MAX_WIDTH float64 = 64
const DEFAULT_MAX_HEIGHT float64 = 64

// 计算图片缩放后的尺寸
func calculateRatioFit(srcWidth, srcHeight int) (int, int) {
ratio := math.Min(DEFAULT_MAX_WIDTH/float64(srcWidth), DEFAULT_MAX_HEIGHT/float64(srcHeight))
return int(math.Ceil(float64(srcWidth) * ratio)), int(math.Ceil(float64(srcHeight) * ratio))
}

// 生成缩略图
func makeThumbnail(imagePath, savePath string) error {

file, _ := os.Open(imagePath)
defer file.Close()

img, _, err := image.Decode(file)
if err != nil {
return err
}

b := img.Bounds()
width := b.Max.X
height := b.Max.Y

w, h := calculateRatioFit(width, height)

fmt.Println("width = ", width, " height = ", height)
fmt.Println("w = ", w, " h = ", h)

// 调用resize库进行图片缩放
m := resize.Resize(uint(w), uint(h), img, resize.Lanczos3)

// 需要保存的文件
imgfile, err := os.Create(savePath)
if err != nil {
fmt.Printf("os create file, err:%v\n", err)
return err
}
defer imgfile.Close()

// 以PNG格式保存文件
err = png.Encode(imgfile, m)
if err != nil {
return err
}

return nil
}

func main() {
var imageFile string
var saveFile string

flag.StringVar(&imageFile, "file", "", "--image file")
flag.StringVar(&saveFile, "dest", "", "--dest file")
flag.Parse()

if len(imageFile) == 0 || len(saveFile) == 0 {
fmt.Printf("%s -file image filename -dest dest filename\n", os.Args[0])
return
}

err := makeThumbnail(imageFile, saveFile)
if err != nil {
fmt.Printf("make thumbnail failed, err:%v\n", err)
return
}
fmt.Printf("make thumbnail succ, path:%v\n", saveFile)
}