如何掌握牢靠Go语言的容器？

容器相对来说更偏重细节一些，如果想掌握的更牢靠的话呢，还是要多看一下代码，重点给大家几个提示

Go语言的并发初步有哪两个特别重要的特点？

**GO语言的协程并发操作或者说协程的资源池，其调度策略有两个： **

1、没有优先级，没有API能设置优先级，正是因为它一切都是靠Go语言自身的一个调度器来听调度，才能保证它的高效率，这点非常重要。

2、调度的策略是可抢占的，假如说一个任务它长时间的占用CPU，那么它是有可能被购入天的这个调度器给其抢占过来，让其其的任务来做运行，这是两个最重要的特点。

GO语言调度的单元goroutine的应用场景是什么？

使用JAVA或者C编写网络程序时，一个线程来处理一个http请求， 但是对于资源的利用率不高。而Go语言实现了轻量级线程的机制，GO语言在底层封装了所有的系统调用，自己实现了一个调度器，这种设计在操作系统的代码中非常多见。比如现代的操作系统基本都会封装一个软件的Timer，同时可以提供上万个软Timer同时工作，而这只是基于数量很少的硬件timer实现的，而GO语言中的并发也是如此，他是基于线程的调度池，这种调度的单元在Go语言中被称为goroutine。

GO语言与其它并发模型最大的区别是什么？

宏观GO语言与其它并发模型最大的不同，就是其推荐使用通信的这种方式来替代共享内存。当资源需要在goroutine之间进行共享的时候，实际上就是这个资源，或者说这个信息通过通道在goroutine之间进行通信的过程。因为这个锁，一般来说都是用在这个共享内存当中的，因为如果说大家阅读GO语言的相关代码，就可以看到这个channel，它实际上是基于锁来保证并发安全。

然而，这也不代表GO语言当中只能使用channel来进行一些操作，其也具备锁这方面的知识。因为现实当中，这个锁还是有一定它现实的意义和现实的要求，因为这个锁它最关键的一个意义就是它能保证资源能在并发的操作当中有一个合理的调度情况和调度策略。其中跟这个最重要，或者说最关联性最强的一个概念就是原子操作。

GO语言中的原子操作具体实现过程是怎样的？

对于原子操作，在其逻辑下，按照它书面的定义上来讲，是指不会被调度器打断的操作。对原子操作实际上就是不存在中间状态的一种操作，要不就全成功，要不全失败，这个在我们在用并发方式来调动某任务，或者说来设计某种并发系统的情况下，这种名字操作我发现是非常重要的设计理念之一。

并发与并行具体概念及实际区分是怎样的？

有一个比较重要的一个概念，就是并发与并行，其实并发与并行，它实际上具体的含义是不一样的，并发实际上是把任务在不同的时间点交给同样一个处理器来进行处理，在同一个时间点，任务不会同时进行，只是任务感觉自己正在执行，因为其那会儿可能正在堵塞状态或者说是就绪状态，其不知道自己被暂停了，以为已经被调度走了，可能自己没有感知，但是实际上CPU所有权已经不在这个任务身上了。

并行比并发更高级一些，它实际上是把每个任务都交给独立的处理器去进行完成，但同一时间点，任务在一定程度上实际上是同时在执行的。一般来说，并发的性能是要比并行更重要一些，在1.5版本之前，我们需要人工去设置GO调度器最多能运行在多少个CPU上，但是在最新的GO版本当中，已经不需要这个相关的操作。

详细介绍一下并发程序中的竞争态？

并发系统设计最初始的这一个概念就是并发程序设计当中一个竞合的概念，或者也叫竞争态。假如说我要记录一个文件的阅读量，但是这个文件或者说这个网页，可能它的阅读渠道有非常多，有可能通过引擎通过微信通过APP等等这些渠道，这些渠道的话呢，它的阅读也都是并发的，这就会涉及到同样一个变量，被多个协程的所共同访问的情况。具体代码如下：

对于GO语言并发体系中的主推的通信机制是什么？

channel是GO语言并发体系中的主推的通信机制，它可以让一个 goroutine 通过它给另一个 goroutine 发送值信息。每个 channel 都有一个特殊的类型，也就是 channels 可发送数据的类型。一个可以发送 int 类型数据的 channel 一般写为 chan int。

GO语言当中，它实际上是大家协同的机制，通过这种方式让几个goroutine之间做达到一个协调的效果，那么每个goroutine当中，实际上channel都是一个特殊的类型，它实际上是可以发送数据。比如现在想发送一个int类型的数据，那么channel就要定义一个发送int数据的一个管道。

那么GO语言当中，提倡使用通讯的方式来代替共享内存的方式来做goroutine，或者说并发之间的一个协同。channel如果我们后续阅读它的代码就会知道，它是保证协程安全，并且它遵循这个先入先出的原则来让这个储蓄方读取获得数据，而且它能保证顺序，正是这两个特性，可以让这个channel替代共享内存，因为它的如果顺序有所改变的话，它实际上也是有会有问题。

详细介绍GO语言中关于通道的声明涉及哪些方面？

1.经典方式声明

通过使用chan类型，其声明方式如下： var name chan type 其中type表示通道内的数据类型；name：通道的变量名称，不过这样创建的通道只是空值 nil，一般来说都是通道都是通过make函数创建的。

2.make方式

make函数可以创建通道格式如下： name := make(chan type)

3.创建带有缓冲的通道

后面会讲到缓冲通道的概念，这里先说他的定义方式 name := make(chan type, size) 其中type表示通道内的数据类型；name：通道的变量名称，size代表缓冲的长度。

具体介绍通道数据收发的详细过程有哪些？

1. 通道的数据发送

通道当中发送数据的操作服务是这样的这样的一个大于号加上一个减号。 chan <- value 注意，如果是发送给一个没有缓冲的一个通道。假如说数据没有被接收的话，那么这个发送操作将持续被注册，也就是说就是channel这个语句就直接被注册到这，假如说没有任何的协程去读到他或者其他语句去读到这个产品，那么这个语句就被注册掉了。但GO语言是能发现的，如果其一直在堵塞的话，那实际上就造成死锁，GO语言的编译器实际上能发现的有点错误。

假如说，首先创建一个int型的通道，然后直接尝试发送一个数据给它，编译会报错，然后呢，数据的这个数据的接收的话，实际上就是把这个点号的位置跟那个大于号的位置做了一个调换。其实把这个双方的位置做了一个调换之后，是实际上就是都做了一个允许的操作。这其中的话呢，还有一种比较特殊的一个读取操作是其可以忽略到接收到的数据，因为不管管道中发出的数据，如果没读的话就堵塞到这，那么如果你觉得这个语句你也不需要，那么你可以把那个变量给它忽略掉。

2.通道的数据接收

通道接收数据的操作符也是<-，具体有以下几种方式 - 1) 阻塞接收数据 阻塞模式接收数据时，将接收变量作为<-操作符的左值，格式如下： data := <-ch 执行该语句时将会阻塞，直到接收到数据并赋值给 data 变量。 如需要忽略接收的数据，则将data变量省略，具体格式如下： <-ch - 2) 非阻塞接收数据 使用非阻塞方式从通道接收数据时，语句不会发生阻塞，格式如下： data, ok := <-ch 非阻塞的通道接收方法可能造成高的 CPU 占用，因此使用非常少。一般只配合select语句配合定时器做超时检测时使用。

关于通道数据收发有哪些需要注意的事项？

1. 通道数据在进行输入收发的时候，必须要在两个不同的goroutine当中进行，因在同一个goroutine当中,收发的这些语句实际上都是堵塞的，你可能在同一个goroutine当中，它的这个函数已经在那边阻塞住了，或者说程序已经在那边阻塞住了，它已经停在那了，你后面有一句你能执行不到，所以说通道的收发必须在两个不同的goroutine之间来进行，在同一个goroutine之间的这个收发操作的话，实际上是没有意义的。

2. 接收将持续堵塞，直到发送方发送出去，如果接收方接收，然后通道中没有发送方数据时，接收方也会发送，直到发送方到发送数据为止。就是刚才说的这个一体两面，这个发送方假如说没有人读的话，发送方会堵塞，假如说没有人写的话，那么接收方也会发生堵塞，这两边实际上都会有一个堵塞的情况。那么这个通道的收发的话呢，一般来说一次只能收一一个元素，假如说这个是一个有缓冲的一个通道，我通过一次不操作的话，实际上也只不过读出一个元素。不能把它一些缓冲区所有元素都读出来。

聊一下生产者消费者模式具体内容有哪些？

介绍一下生产者消费者模式，从GO语言的这个并发模型来看，也就是说假如说咱们站在一个比较高的一个高度来看，其实利用channel的确能达到共享内存的目的。这个channel的性质与在读写状态且保证顺序的共享内存并无不同。甚至我们可以说这个是基于消息队列的封装程度可以比共享内存来的更安全，所以说呢，这个在这个GO语言当中，或者说在GO语言的这个设计风格当中的话呢，其这个生产者消费者模式实现起来会相对来说比较简单一些。我们先介绍一下什么是生产者消费者。 就这个这这张图当中的话呢，就是一个典型的那种消费的问题，

就是说我是生产者的话我会生产一些产品，然后放到这个仓库当中，消费者的话会从那个仓库当中去取商品，这个可以说是消息队列，还有包括卡夫卡那些比较经典的相应队列当中，都会用到的这么一个设计模式，或者说其们从本质上来说的话，都是基于这样一个设计模式，交易的生产者是谁？消费者是谁？这个消息队列的话是。这个生产者消费者模式的话呢，实际上也成为有缓冲有限缓冲问题，它是一个并发的一个经典的案例，因为我们知道这个商品仓库的库房大小是有限的，也就是说生产者不能无限的去生产商品，一旦这个库房爆掉的话，它是它是必须要中止自己的生产，消费者也是不能无限地获取消息。 假如仓库是空的话，那这个消费者的这个相关的情况也需要被阻塞。那么怎么在这个生产者跟消费者之间保证商品不丢失。这就是生产者与消费者之间最核心的内容。先来看一下这个Java当中生产者消费者的这种实现到底是什么样的。这个可以说是一个最经典的这么样一个实现。这个Java当中是没有channel，那么它只能通过什么呢，只能通过信号量和一个一个log，也就是说一个忽视服务态度，这两个这两个配合信号量和所配合才能共同完成，这样一个生产者消费者这么一个相关的工作。

GO语言并发实战详细过程梳理

在现在这个远程办公的这一个大的背景下，积累了大量重复的文件，因为很可能大家都不断的在不同的群里发相同的文件，发相同的这个报表，以及一些相同的视频等等这些需要学习的材料，那么怎么把这些文件都找出来，然后把这些相同文件都给删掉了，这实际上是并发课的一个实践的一个内容，因为这个创业型的这个方案的话，它的代码相对来说比较长。 如何使用GO语言清理PC机中的文件,详细代码及注释如下：

package main

import ( // "fmt" // fmt 包使用函数实现 I/O 格式化（类似于 C 的 printf 和 scanf 的函数）, 格式化参数源自C，但更简单 "io/ioutil" //"sync" //"time" )

func PrintRepreatFile(path string, fileNameSizeMap map[string]int64, exFileList []string) {

fs, _ := ioutil.ReadDir(path)
for _, file := range fs {
	if file.IsDir() {
		
		PrintRepreatFile(path+"/"+file.Name(), fileNameSizeMap, exFileList)//遍历整个文件系统，如果是目录则递归调用
	
	} else {

		if file.Size() > 1000000 {//设定文件清理阈值，如果大于一定大小再进行清理
			fileSize := fileNameSizeMap[file.Name()]//通过查哈希表的方式来确定，有无重名且大小相同的文件。

			if fileSize == file.Size() {
				fmt.Println(path + "/" + file.Name())//如果有则打印出来

				exFileList = append(exFileList, path+file.Name())//将结果记入切片当中
			} else {

				fileNameSizeMap[file.Name()] = file.Size()
			}
		}

	}

}

}

func main() { //方式一 fileNameSizeMap := make(map[string]int64, 10000) exFileList := make([]string, 100, 1000) PrintRepreatFile("E:/test", fileNameSizeMap, exFileList)

}

这个程序在GO语言的环境下可以直接运行使用，其中有几个知识点，也是咱们前文提到过的，首先是切片的大小一定要设定的相对合适一些，如果容量不够大造成频繁扩容非常浪费资源。二是哈希表也就是map没有并发安全的属于，在我们这个未引入并发的程序中可以使用，如果有并发操作，那么map不再适用了。

可能很多人被GO语言的在并发性能所吸引入坑的，GO语言之父也就是UNIX之父Ken Thompson明显给出了很多建议，根据笔者在操作系统方面的相关经验来看，GO语言设计中经常参考UNIX内核的设计思路。比如硬定时器的数量有限，无法满足系统实际运行需要，所以在内核代码中就会看到基于硬件定时器的软件定时器的方案，而软件定时器的数量可以比硬件定时器多几百倍。 这样的理念明显融合到了 goroutine之中，由于其它编程语言往往直接通过系统级别的线程来实现并发功能，但是这样的方式往往会是大马拉小车，造成系统资源的浪费。因此GO语言封装了所有的系统操作，实现了更加轻量级的协程-goroutine。只要使用关键字（go）就可以启动协程，对比C++、JAVA的多线程并发模型，GO的协程更简单明了。

当然协程之间的消息通信与并发控制也是非常重要的一环。在GO语言借鉴了Message Queue的消息队列机制替代共享内存的方式进行协程间通信，其中管道channel作为基本的数据类型，保证并发时的操作安全。而且管道的引入还带来很多实践中非常实用的功能，比如可以方便实现生产者、消费者等并发设计模式，而这些设计模式在其它使用共享存内存的并发模型中实现起相关功能来非常的繁锁。

在GO语言中在调用函数前加入go 关键字，就能启动一个协程，也就是一个并发，但是我们上面的程序如果把调用方式改为：

go PrintRepreatFile("E:/test", fileNameSizeMap, exFileList) 你会发现程序会直接退出，什么都没做，所以GO语言的并发对于初学者来说还是有一定门槛的，比如上例中如果想设计成一个并行的程序，如何让多个协程共同来帮忙找出重复的文件其实还是要费一番周折的。