进程Process就是程序在操作系统中的一次执行过程是系统进行资源分配和调度的基本单位进程是一个动态概念是程序在执行过程中分配和管理资源的基本单位每一个进程都有一个自己的地址空间。

一个进程至少有

是进程的一个执行实例是程序执行的最小单元它是比进程更小的能独立运行的基本单位一个进程可以创建多个线程同一个进程中的多个线程可以并发执行一个程序要运行的话至少有一个进程。

并行和并发

并发多个线程同时竞争一个位置竞争到的才可以执行每一个时间段只有一个线程在执行。

CPU

协程可以理解为用户级线程这是对内核透明的也就是系统并不知道有协程的存在是完全由用户自己的程序进行调度的。

Golang

Golang

strconv.Itoa(i))time.Sleep(time.Second)}

func

strconv.Itoa(i))time.Sleep(time.Second)}

}上面代码看上去没有问题但是要注意主线程执行完毕后即使协程没有执行完毕程序会退出所以我们需要对上面代码进行改造。

sync.WaitGroup

strconv.Itoa(i))time.Sleep(time.Millisecond

50)}wg.Done()

strconv.Itoa(i))time.Sleep(time.Millisecond

50)}wg.Wait()

}多次执行上面的代码会发现每次打印的数字的顺序都不一致。

这是因为

goroutine

runtime.GOMAXPROCS()函数设置当前程序并发时占用的

CPU

runtime.NumCPU()fmt.Println(cpuNum,

1)fmt.Println(ok)

Processes提倡通过通信共享内存而不是通过共享内存而实现通信。

语言中的管道channel是一种特殊的类型。

管道像一个传送带或者队列总是遵循先入先出First

First

Out的规则保证收发数据的顺序。

每一个管道都是一个具体类型的导管也就是声明

channel

管道有发送send、接收(receive和关闭close三种操作。

make(chan

close(ch)关于关闭管道需要注意的事情是只有在通知接收方

goroutine

所有的数据都发送完毕的时候才需要关闭管道。

管道是可以被垃圾回收机制回收的它和关闭文件是不一样的在结束操作之后关闭文件是必须要做的但关闭管道不是必须的。

3对一个关闭的并且没有值的管道执行接收操作会得到对应类型的零值。

管道阻塞

如果创建管道的时候没有指定容量那么我们可以叫这个管道为无缓冲的管道

package

main.main()D:/project/go-project/main.go:10

0x28Process

解决上面问题的方法还有一种就是使用有缓冲区的管道。

我们可以在使用

make

}只要管道的容量大于零那么该管道就是有缓冲的管道管道的容量表示管道中能存放元素的数量。

就像你小区的快递柜只有那么个多格子格子满了就装不下了就阻塞了等到别人取走一个快递员就能往里面放一个。

管道阻塞具体代码如下

main.main()D:/project/go-project/main.go:10

0x45Process

panic从该管道取值的操作会先取完管道中的值再然后取到的值一直都是对应类型的零值。

那如何判断一个管道是否被关闭了呢

我们来看下面这个例子

5从上面的例子中我们看到有两种方式在接收值的时候判断该管道是否被关闭不过我们通常使用的是

for

定义两个方法一个方法给管道里面写数据一个给管道里面读取数据。

要求同步进行。

1开启一个

fn2(allChan)wg.Wait()fmt.Println(读取完毕...)

}单向管道

有的时候我们会将管道作为参数在多个任务函数间传递很多时候我们在不同的任务函数中使用管道都会对其进行限制比如限制管道在函数中只能发送或只能接收。

package

在某些场景下我们需要同时从多个通道接收数据。

这个时候就可以用到

golang

}这种方式虽然可以实现从多个管道接收值的需求但是运行性能会差很多。

为了应对这种场景Go

select

程序员可以加入逻辑\n)time.Sleep(time.Second)return}}}Golang

并发安全和锁

互斥锁是传统并发编程中对共享资源进行访问控制的主要手段它由标准库

sync

count)time.Sleep(time.Millisecond)

func

condition。

具体来说多个goroutine同时访问和修改共享变量count而没有适当的同步机制来保护对这个变量的访问。

这会导致不可预测的行为因为不同的goroutine可能会在同一时间尝试读取和写入count从而导致数据竞争。

互斥锁解决这个问题

释放锁time.Sleep(time.Millisecond)

}func

声明一个WaitGroup用于等待所有goroutine完成for

100;

虽然使用互斥锁能解决资源争夺问题但是并不完美通过全局变量加锁同步来实现通讯并不利于多个协程对全局变量的读写操作。

这个时候我们也可以通过另一种方式来实现上面的功能管道(Channel)。

读写锁

都不能访问。

这样在资源同步避免竞争的同时也降低了程序的并发性能。

程序由原来的并行执行变成了串行执行。

其实当我们对一个不会变化的数据只做“读”操作的话是不存在资源竞争的问题的。

因为数据是不变的不管怎么读取多少

goroutine

所以问题不是出在“读”上主要是修改也就是“写”。

修改的数据要同步这样其他goroutine

才可以感知到。

所以真正的互斥应该是读取和修改、修改和修改之间读和读是没有互斥操作的必要的。

读写锁可以让多个读操作并发同时读取但是对于写操作是完全互斥的。

也就是说当一个

goroutine

(*RWMutex)Unlock()另一组表示对读操作的锁定和解锁简称为“读锁定”与“读解锁”

func

{mutex.Lock()fmt.Println(执行写操作)time.Sleep(time.Second

}//

{mutex.RLock()fmt.Println(执行读操作)time.Sleep(time.Second

func

{time.Sleep(time.Second)fmt.Println(hello,world)}

}//

https://www.geeksforgeeks.org/golang-tutorial-learn-go-programming-language/