Go中的并发与并行

1、线程（thread）和进程（process）:

（1）进程 当运行一个应用程序（如一个IDE或者编辑器）的时候，操作系统会为这个应用程序启动一个进程。可以将这个进程看做一个包含了应用程序在运行中需要用到和维护的各种资源的容器。

（2）线程 一个线程是一个执行空间，这个空间会被操作系统调度来运行函数中所写的代码。每个进程至少包含一个线程，每个进程的初始线程被称作主线程。

（3）操作系统线程、逻辑处理器和本地运行队列之间的关系

       创建的goroutine会被放到调度器的全局运行队列中，调度器将这些队列中的goroutine分配给一个逻辑处理器，并放到该逻辑处理器对应的本地运行队列中。本地运行队列中的goroutine会一直等待，直到被分配到逻辑处理器执行。

 

2、并发（concurrency）与并行（parallelism） 

（1）并行 让不同的代码片段同时在不同的物理处理器上执行。

（2）并发 同时管理很多事情，这些事情可能只做了一半就被暂停去做别的事情了。

（3）若想让goroutine并行，必须使用多于一个逻辑处理器。当有多个逻辑处理器时，调度器会将goroutine平均分配到每个逻辑处理器上。

3、举例说明：

（1）分配一个逻辑处理器

func main() {
	runtime.GOMAXPROCS(1) // 分配一个“逻辑处理器”给“调度器”使用
	var wg sync.WaitGroup //wg是计数信号量
	wg.Add(2) //等待两个goroutine
	fmt.Println("Start Goroutines")
	go func(){ //声明一个匿名函数，go关键字创建了一个goroutine
		defer wg.Done() //减小wg的值
		for count := 0; count < 3; count++ {
			fmt.Printf("\n")
			for char := 'A'; char < 'A' + 26; char++ {
				fmt.Printf("%c ", char)}
		}
	}()
	go func(){
		defer wg.Done()
		for count := 0; count < 3; count++ {
			fmt.Printf("\n")
			for char := 'a'; char < 'a' + 26; char++ {
				fmt.Printf("%c ", char)	}
		}
	}()
	fmt.Println("Waiting to Finish")
	wg.Wait() //若wg的值大于0，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
//评注：第一个goroutine完成所需时间太短，以至于调度器切换到第二个goroutine前，就完成了所有任务。

（2）分配两个逻辑处理器，并行执行两个goroutine

func main() {
	runtime.GOMAXPROCS(2) // 分配两个“逻辑处理器”给“调度器”使用
	var wg sync.WaitGroup //wg是计数信号量
	wg.Add(2) //等待两个goroutine
	fmt.Println("Start Goroutines")
	go func(){ //声明一个匿名函数，go关键字创建了一个goroutine
		defer wg.Done() //减小wg的值
		for count := 0; count < 3; count++ {
			fmt.Printf("\n")
			for char := 'A'; char < 'A' + 26; char++ {
				fmt.Printf("%c ", char)}
		}
	}()
	go func(){
		defer wg.Done()
		for count := 0; count < 3; count++ {
			fmt.Printf("\n")
			for char := 'a'; char < 'a' + 26; char++ {
				fmt.Printf("%c ", char)	}
		}
	}()
	fmt.Println("Waiting to Finish")
	wg.Wait() //若wg的值大于0，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 
A B C D E F G H e f g h i j k l m n o p q r s t u v w x y z 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

（3）一个正在运行的goroutine在工作结束前，可以被停止并重新调度。调度器这样做的目的是防止某个goroutine长时间占用逻辑处理器，例：

func main() {
	runtime.GOMAXPROCS(1) // 分配一个“逻辑处理器”给“调度器”使用
	var wg sync.WaitGroup //wg是计数信号量
	wg.Add(2) //等待两个goroutine
	fmt.Println("Start Goroutines")
	go func(){ //声明一个匿名函数，go关键字创建了一个goroutine
		defer wg.Done() //减小wg的值
		for count := 0; count < 3; count++ {
			fmt.Printf("\n")
			time.Sleep(3*time.Second)
			for char := 'A'; char < 'A' + 26; char++ {
				fmt.Printf("%c ", char)}
		}
	}()
	go func(){
		defer wg.Done()
		for count := 0; count < 3; count++ {
			fmt.Printf("\n")
			time.Sleep(3*time.Second)
			for char := 'a'; char < 'a' + 26; char++ {
				fmt.Printf("%c ", char)	}
		}
	}()
	fmt.Println("Waiting to Finish")
	wg.Wait() //若wg的值大于0，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