//这个程序展示如何创建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

*/