//这个程序展示如何创建goroutine
//以及调度器的行为
package main

import (
	"fmt"
	"runtime"
	"sync"
)

//main是程序的入口
func main() {
	//分配一个逻辑处理器给调度器使用
	runtime.GOMAXPROCS(1)

	//wg用来等待程序完成
	//通过设定计数器，让每个goroutine在退出前递减，直至归零时解除阻塞。
	var wg sync.WaitGroup
	//计数加2，表示要等待两个goroutine
	wg.Add(2)

	fmt.Println("Start Goroutines")

	//声明一个匿名函数，并创建一个goroutine
	go func() {
		//在函数退出时调用Done来通知main函数工作已经完成
		defer wg.Done()

		//显式字母表三次
		for count := 0; count < 3; count++ {
			for char := 'a'; char < 'a'+26; char++ {
				fmt.Printf("%c ", char)
			}
		}
	}()

	go func() {
		defer wg.Done()

		for count := 0; count < 3; count++ {
			for char := 'A'; char < 'A'+26; char++ {
				fmt.Printf("%c ", char)
			}
		}
	}()

	fmt.Println("waiting To finish")
	//等待goroutine结束
	wg.Wait()

	fmt.Println("\nTerminating Program")
}

Start Goroutines
waiting To finish
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
a b c d e f g h i j k l m n o p q r s t u v w x y z 
a b c d e f g h i j k l m n o p q r s t u v w x y z
a b c d e f g h i j k l m n o p q r s t u v w x y z 
Terminating Program

package main

import (
	"fmt"
	"runtime"
	"sync"
)

var wg sync.WaitGroup

func main() {
	runtime.GOMAXPROCS(1)

	wg.Add(2)

	fmt.Println("create goroutine")
	go printPrime("A")
	go printPrime("B")

	fmt.Println("waiting to finish")
	wg.Wait()
	fmt.Println("Terminating program")

}

func printPrime(prefix string) {
	defer wg.Done()

next:
	for outer := 2; outer < 5000; outer++ {
		for inner := 2; inner < outer; inner++ {
			if outer%inner == 0 {
				continue next
			}
		}
		fmt.Printf("%s:%d\n", prefix, outer)
	}
	fmt.Println("completed", prefix)
}


/*
create goroutine
waiting to finish
B:2
B:3
...
B:4787
B:4789
A:2      //切换goroutine
A:3
...
A:3919
A:3923
B:4793   //切换goroutine
B:4799
...
B:4993
B:4999
completed B
A:3929   //切换goroutine
A:3931
...
A:4999
completed A
Terminating program
*/

//如何在程序里造成竞争状态
//实际上不希望出现这种情况
package main

import (
	"fmt"
	"runtime"
	"sync"
)

var (
	//counter是所有goroutine都要增加其值的变量
	counter int

	//wg用来等待程序结束
	wg sync.WaitGroup
)

func main() {
	//计数加2，要等待两个goroutine
	wg.Add(2)

	//创建两个goroutine
	go inCounter(1)
	go inCounter(2)

	//等待goroutine结束
	wg.Wait()
	fmt.Println("Final Counter:", counter)
}

//inCounter增加包里counter变量的值
func inCounter(id int) {
	//在函数退出时调用Done来通知main函数工作已经完成
	defer wg.Done()

	for count := 0; count < 2; count++ {
		//捕获counter的值
		value := counter

		//当前goroutine从线程退出，并放回队列
		runtime.Gosched()

		//增加本地value变量的值
		value++

		//将值保存回counter
		counter = value

	}
}　　

Final Counter: 2

//展示如何使用atomic包来提供对数值类型的安全访问
package main

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

var (
	//counter是所有goroutine都要增加其值的变量
	counter int64

	//wg用来等待程序结束
	wg sync.WaitGroup
)

func main() {
	//计数加2，要等待两个goroutine
	wg.Add(2)

	//创建两个goroutine
	go inCounter(1)
	go inCounter(2)

	//等待goroutine结束
	wg.Wait()
	fmt.Println("Final Counter:", counter)
}

//inCounter增加包里counter变量的值
func inCounter(id int) {
	//在函数退出时调用Done来通知main函数工作已经完成
	defer wg.Done()

	for count := 0; count < 2; count++ {
		atomic.AddInt64(&counter, 1)

		runtime.Gosched()
	}
}

/*
结果：
Final Counter: 4
*/

//这个示例程序展示如何使用atomic包里的Store和Load类型函数来提供对数值类型的安全访问。
package main

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

var (
	//shutdown是通知正在执行的goroutine停止工作的标志
	shutdown int64

	//wg用来等待程序结束
	wg sync.WaitGroup
)


func main() {

	wg.Add(2)

	//创建两个goroutine
	go doWork("A")
	go doWork("B")

	//给定goroutine执行时间
	time.Sleep(1 * time.Second)

	//该停止工作了，安全设置shutdown标志
	fmt.Println("Shutdown Now")
	atomic.StoreInt64(&shutdown, 1)


	wg.Wait()
}

//doWork用来模拟执行工作的goroutine
//检测之前的shutdown标志来决定是否提前终止
func doWork(name string) {
	defer wg.Done()

	for {
		fmt.Printf("Doing %s Work\n", name)
		time.Sleep(250 * time.Millisecond)

		//要停止工作了吗？
		if atomic.LoadInt64(&shutdown) == 1 {
			fmt.Printf("Shutting %s Down\n", name)
			break
		}
	}
}

//展示互斥锁，定义临界区
package main

import (
	"fmt"
	"runtime"
	"sync"
)

var (
	counter int
	wg      sync.WaitGroup
	//mutex用来定义一段代码临界区
	mutex sync.Mutex
)

func main() {
	wg.Add(2)

	go inCounter(1)
	go inCounter(2)

	wg.Wait()
	fmt.Println("Final Counter:", counter)
}

func inCounter(id int) {

	defer wg.Done()

	for count := 0; count < 2; count++ {
		//同一时刻只允许一个goroutine进入
		//定义临界区
		mutex.Lock()
		{
			value := counter

			runtime.Gosched()

			value++

			counter = value
		}
		mutex.Unlock()
		//释放锁，允许其它正在等待的goroutine进入临界区
	}
}

/*
结果：
Final Counter: 4
*/