# 结构体知识小问题
* * * * *
--: 作者:Mick
时间:2018年11月18日
* * * * *
### 概念理解
1：并发的关键是你有处理多个任务的能力，一件一件间隔的完成
你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发。 （不一定是同时的）
2：并行的关键是你有同时处理多个任务的能力
你吃饭吃到一半，电话来了，你一边打电话一边吃饭，这说明你支持并行
#### 实例展示
思考逻辑处理器：多少是并发？多少是并行？
```
func main(){
runtime.GOMAXPROCS(1)
var wg sync.WaitGroup
wg.Add(2)
go onCpuNum("A",&wg)
go onCpuNum("B",&wg)
wg.Wait()
}
//并发输出5000以内的素数
func onCpuNum(pre string,wg *sync.WaitGroup){
defer wg.Done()
next:
for i:=2;i<5000;i++{
for j:=2;j<i;j++{
if i%j == 0{
continue next
}
}
fmt.Printf("%s:%d\n",pre,i)
}
}
```
### 并发导致锁问题
```
func race(){
var num int
var wg sync.WaitGroup
wg.Add(2)
go func(){
defer wg.Done()
for i:=0;i<10000;i++{
num++
}
}()
go func(){
defer wg.Done()
for i:=0;i<10000;i++{
num++
}
}()
wg.Wait()
fmt.Println(num)
}
```
### 解决方案
加锁：锁住共享资源，原子函数与互斥锁
通道：在goroutinue之间传递数据的类型，采用通信顺序进程（CSP）模型进行通信
#### 原子函数
累加函数：atomic.AddInt64(addr *int64, delta int64) (new int64)
写函数: atomic.StoreInt64(addr *int64, val int64)
读函数 : atomic.LoadInt64(addr *int64) (val int64)
请使用上述函数对竞状态函数进行改造？？？
原子函数示例
```
func atomicStoreLoad(){
var wg sync.WaitGroup
var shutdown int64
wg.Add(2)
go func(){
defer wg.Done()
for {
fmt.Println("Doing jack work")
time.Sleep(time.Millisecond*250)
if atomic.LoadInt64(&shutdown) == 1 {
fmt.Println("Shutdown jack work")
break
}
}
}()
go func(){
defer wg.Done()
for {
fmt.Println("Doing tom work")
time.Sleep(time.Millisecond*250)
if atomic.LoadInt64(&shutdown) == 1 {
fmt.Println("Shutdown tom work")
break
}
}
}()
time.Sleep(time.Second)
fmt.Println("shutdown now")
atomic.StoreInt64(&shutdown,1)
wg.Wait()
}
```
#### 互斥锁
sync.Mutex结构体是对原子函数的封装实现区域保护
```
func mutexLock(){
var wg sync.WaitGroup
var num int
var mutex sync.Mutex
wg.Add(2)
go func(){
for i:=0;i<10000;i++{
mutex.Lock()
num++
mutex.Unlock()
}
defer wg.Done()
}()
go func(){
for i:=0;i<10000;i++{
mutex.Lock()
num++
mutex.Unlock()
}
defer wg.Done()
}()
wg.Wait()
fmt.Println(num)
}
```
## 存在问题，解决了资源的安全访问以及消除竞争状态，但是goroutinue之间怎么通信（传递变量） ？？？
### 通道
