go chan基本使用-Toy模板网

这篇具有很好参考价值的文章主要介绍了go chan基本使用。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1、有缓冲的chan 与无缓冲的chan

怎么理解这个缓冲，我个人的理解是是执行这个chan 操作的时候是否发送阻塞。
操作：读和写。
读取的时候，我们都应该要是阻塞的，例如我们的socket、的recv函数。当然取决于你设置的是阻塞的套接字还是非阻塞的套接字了。
无缓冲的chan，讲究读写对称，也就是你在读的时候会阻塞，看下面这个例子：ch是一个无缓冲的chan,在主线程里面，ch<-发送了阻塞。所以后面没法执行了。

func TestChan1(t *testing.T) {
	ch := make(chan int)
	<-ch
	ch<-1
}

go chan基本使用
我们对此进行修改,同样的也是无缓冲的chan,只不过让读操作异步，也就是不是阻塞在主线程了，让主线程可以继续执行。

func TestChan1(t *testing.T) {
	ch := make(chan int)
	go func() {
		val := <-ch
		fmt.Println(val)
	}()
	ch<-1
	time.Sleep(1*time.Second)
}

go chan基本使用

以上是无缓冲chan 的读操作，假设我们是先写呢？我们应该可以猜想到，写可能发生阻塞也可能不发生阻塞。那么无缓冲的chan 到底会不会阻塞呢？我们看下面的例子

func TestChan1(t *testing.T) {
	ch := make(chan int)
	ch <- 1
	<-ch
}

go chan基本使用
运行之后，发生了死锁。
对此我们可以得出的初步结论是：无缓冲的chan 读写都是阻塞的。
同理我们对此进行修改

func TestChan1(t *testing.T) {
	ch := make(chan int)
	go func() {
		ch <- 1
	}()
	val := <-ch
	fmt.Println(val)
}

go chan基本使用
无缓冲的chan的介绍，到以上就结束，我们看一下有缓冲的chan。

2、有缓冲的chan

猜想一下有缓冲的chan 是什么存在缓冲，也就是说是读写操作哪个是非阻塞的，还是都是非阻塞的。我们看下面的例子。
第一个例子

func TestChan1(t *testing.T) {
	ch := make(chan int,1)
	ch <- 1
	val := <-ch
	fmt.Println(val)
}

先写入ch 然后读取。运行
go chan基本使用
这里我们得到结论：写是非阻塞。
第2 个例子：

func TestChan1(t *testing.T) {
	ch := make(chan int,1)
	<-ch
	ch <- 1
}

很显然我们可以猜到，会死锁。运行
go chan基本使用
对此我们对于有缓冲的chan得出的结论：读取是阻塞的。

同理，针对上面的修改：

func TestChan1(t *testing.T) {
	ch := make(chan int,1)
	go func() {
		val := <-ch
		fmt.Println(val)
	}()
	ch <- 1
	time.Sleep(1 *time.Second)
}

go chan基本使用
对此我们对于chan有了一个基本的认识与使用。接下来看一下chan 几个应用实例。

3、利用chan 实现生产者消费者

生产者与消费者，说白了就是一个线程负责产生数据，另外一端消费数据。对应于我们的读写操作上来，生产者写数据，消费者读数据。对于该模型是不是，很容易利用chan来实现呢？假设我们现在是1个生产者，1个消费者，那么我们应该利用几个chan呢，很显然是一个chan 就够了，因为写入需要阻塞，那么我们的produce 是需要一个线程的，对于消费者，我们也需要一个线程，具体实现：

func TestChan1(t *testing.T) {
	ch := make(chan int,1)
	defer close(ch)
	go func() {
		for i := 0;i<10;i++ {
			ch<-i
			fmt.Println("send:",i)
		}
	}()

	go func() {
		for {
			select {
			case val, ok := <-ch:
				if ok {
					fmt.Println("recv:", val)
				} else {
					return
				}
			}
		}
	}()

	/*go func() {
		for c := range ch {
			fmt.Println(c)
			fmt.Println("recv:",c)
		}
	}()*/
	time.Sleep(1 *time.Second)
}

针对接收数据，我们通常采用以下这种模式。

for {
 select {
   case <- ch:
   case <-ctx.Down:
   ....
 }
}

4、利用chan 实现同步

两条线程交替打印，例如：1-100，两条线程交替打印。
分析一下这个操作，时间上我们利用的是chan的读取阻塞的特性，实际上就是利用chan 实现同步。

func TestChan1(t *testing.T) {
	ch1 := make(chan int)
	ch2 := make(chan int)

	go func() {
		for i := 0; i < 50; i++ {
			<-ch1
			fmt.Println(2*i + 1)
			ch2 <- 1
		}
	}()

	go func() {
		for i := 0; i < 50; i++ {
			<-ch2
			fmt.Println(2*i + 2)
			ch1 <- 1
		}
	}()
	ch1 <- 1

	time.Sleep(1 * time.Second)
}

5、并发处理

假设我们有一个任务，这个任务可以分成很多份，每个任务处理的都是相同的内容，例如多线程查询，汇总。多线程上传。具体的chan 模板代码：

// eg1: 假设10条线程处理，采用10个chan的方式
var res = 0
func TestChan() {
	ch := make(chan int,1)
	closeCh := make(chan int,1)
	defer close(ch)
	for i := 1;i<=10;i++ {
		item := i
		go func() {
			ch <- item
		}()
	}


	go func() {
		for i := 0;i<10;i++{
			c := <- ch
			res += c
			//fmt.Println(val)
		}
		closeCh<-1
	}()
	<-closeCh
	fmt.Println(res)
}

运行结果
go chan基本使用
使用waitgroup文章来源地址https://www.toymoban.com/news/detail-427632.html

func WgTest() {
	ch := make(chan int, 1)
	closeCh := make(chan int,1)
	wg := sync.WaitGroup{}
	wg.Add(2)
	go Produce(ch,&wg)
	go Produce(ch,&wg)
	go Merge(ch,closeCh)

	wg.Wait()
	close(ch)
	<-closeCh
	fmt.Println(result)
	return
}

func Produce(ch chan int, wg *sync.WaitGroup) {
	defer func() {
		wg.Done()
	}()
	for i := 0; i < 10; i++ {
		ch <- i
	}
	return
}

var result = 0
func Merge(ch,closeCh chan int) {
	for {
		select {
		case val,ok := <-ch:
			if ok {
				result += val
			}else {
				closeCh<-1
				return
			}
		}
	}
}