3.2 Go之语言并发通信

3.2 Go之语言并发通信

并发编程的难点

并发编程的难度在于协调，协调就需要交流，并发单元间的通信是最大的问题

常见的并发通信模型

• 共享数据

• 消息

---

共享数据

概念：

多个并发单元分别保存对同一个数据的引用，实现对该数据的共享。实际工程中主要是指共享内存。

C语言共享内存示例：

/* 头文件宏引入 */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
​
void *count()
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
​
/* 定义main函数 */
int main()
{
    int rc1, rc2;
    pthread_t thread1, thread2;
    /* 创建线程，每个线程独立执行函数functionC */
    if ((rc1 = pthread_create(&thread, NULL, &count NULL)))
    {
        printf("Thread creation failed: %d\n", rc1);
    }
    if((rc2 = pthread_create(&thread2, NULL, &count, NULL)))
    {
        printf("Thread creation failed: %d\n", rc2);
    }
    /* 等待所有线程执行完毕 */
    pthread_join( thread1, NULL);
    pthread_join( thread2, NULL);
    exit(0);
}
​
/* 定义count函数 */
void *count()
{
    pthread_mutex_lock( &mutex1 );
    counter++;
    printf("Counter value: %d\n",counter);
    pthread_mutex_unlock( &mutex1 );
}

使用Go实现数据共享：

设置十个goroutine共享一个counter变量：

package main
​
import (
    "fmt"
    "runtime"
    "sync"
)
​
/* 声明一个counter变量 */
var counter int = 0
​
/* 调用sync包下的函数 */
func Count(lock *sync.Mutex) {
    /* 上锁 */
    lock.Lock()
    /* 变量自增，防止争抢 */
    counter++
    // 打印结果
    fmt.Println(counter)
    // 解锁
    lock.Unlock()
}
​
/* 调用main函数 */
func main() {
    /* 声明sync.Mutex结构体对象 */
    lock := &sync.Mutex{}
    // 循环开启十个goroutine调用Count函数
    for i := 0; i < 10; i++ {
        /*
        特点：
        1、10 个 goroutine 中共享了变量 counter。每个 goroutine 执行完成后，会将 counter 的值加 1
        2、10 个 goroutine 是并发执行的，引入了锁，每次对变量的操作都需要先锁住，操作完成后将锁释放
         */
        go Count(lock)
    }
​
    /* 使用 for 循环来不断检查 counter 的值（同样需要加锁）。当其值达到 10 时，说明所有 goroutine 都执行完毕了，这时主函数返回，程序退出。 */
    for {
       lock.Lock()
       /* 检查counter变量所以声明count变量 */
       c := counter
       lock.Unlock()
       /* 判断如果是到10了直接退出 */
       runtime.Gosched()
        if c >= 10 {
            break
        }
    }
}

小结：

上诉代码基本上是java、c等语言处理共享数据时候的用法。Go语言提供了另一种通信模型，以消息机制而非共享内存作为通信方式

消息机制的通信方式

消息机制认为每个并发单元是自包含的、独立的个体，并且都有自己的变量，但在不同并发单元间这些变量不共享。每个并发单元的输入和输出只有一种，那就是消息。

特点：

靠消息来通信，它们不会共享内存。Go语言中的消息通信机制称之为channel