go chan基本使用详解

目录

• 1、有缓冲的chan 与无缓冲的chan
• 2、有缓冲的chan
• 3、利用chan 实现生产者消费者
• 4、利用chan 实现同步
• 5、并发处理

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

怎么理解这个缓冲，我个人的理解是是执行这个chan 操作的时候是否发送阻塞。

操作：读和写。

读取的时候，我们都应该要是阻塞的，例如我们的socket、的recv函数。当然取决于你设置的是阻塞的套接字还是非阻塞的套接字了。

无缓冲的chan，讲究读写对称，也就是你在读的时候会阻塞，看下面这个例子：ch是一个无缓冲的chan,在主线程里面，ch<-发送了阻塞。所以后面没法执行了。

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

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

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

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

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

运行之后，发生了死锁。

对此我们可以得出的初步结论是：无缓冲的chan 读写都是阻塞的。

同理我们对此进行修改

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

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

2、有缓冲的chan

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

第一个例子

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

先写入ch 然后读取。运行

这里我们得到结论：写是非阻塞。

第2 个例子：

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

很显然我们可以猜到，会死锁。运行

对此我们对于有缓冲的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)
}

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

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

生产者与消费者，说白了就是一个线程负责产生数据，另外一端消费数据。对应于我们的读写操作上来，生产者写数据，消费者读数据。对于该模型是不是，很容易利用c编程客栈han来实现呢？假设我们现在是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)
}

运行结果

使用waitgroup

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()
	clospythone(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
			}
		}
	}
}

到此这篇关于go chan基本使用详解的文章就介绍到这开发者_JAVA学习了,更多相关go chan使用内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！