golang channel多生产者和多消费者实例

package main
import (
    "fmt"
    "time"
)
func consumer(cname string, ch chan int) { 

       //可以循环 for i := range ch 来不断从 channel 接收值,直到它被关闭。

    for i := range ch {
        fmt.Println("consumer-----------", cname, ":", i)
    }
    fmt.Println("ch closed.")
 }

func producer(pname string, ch chan int) {
    for i := 0; i < 4; i++ {
        fmt.Println("producer--", pname, ":", i)
        ch <- i
    }
 }

 func main() {
    //用channel来传递"产品", 不再需要自己去加锁维护一个全局的阻塞队列
    ch := make(chan int)
    go producer("生产者1", ch)
    go producer("生产者2", ch)
    go consumer("消费者1", ch)
    go consumer("消费者2", ch)
    time.Sleep(10 * time.Second)
    close(ch)
    time.Sleep(10 * time.Second)
 }

for i := range ch {
        fmt.Println("consumer-----------", cname, ":", i) 

    } 

这个也可以改成:LOOP:
    for {
        select {
            case i,ok:=<-ch:
                if ok {
                    fmt.Println("consumer--------", cname, ":", i)
                } else {
                    break LOOP
                }

        }

    }

//注意: i := <- ch  从空的channel中读取数据不会panic, i读取到的值是0,  如果channel是bool的,那么读取到的是false

//判断channel是否关闭,可以使用像上面的ok pattern

channel 本身就是并发安全的。

原文地址:https://www.cnblogs.com/ExMan/p/12408655.html

时间: 2024-11-08 10:51:45

golang channel多生产者和多消费者实例的相关文章

Linux多线程机制(生产者和消费者实例 )

    使用多线程的理由之一是和进程相比,它是一种非常"节俭"的多任务操作方式.我们知道,在Linux系统下,启动一个新的进程必须分配给它独立 的地址空间,建立众多的数据表来维护它的代码段.堆栈段和数据段,这是一种"昂贵"的多任务工作方式.而运行于一个进程中的多个线程,它们彼此之间使用相 同的地址空间,共享大部分数据,启动一个线程所花费的空间远远小于启动一个进程所花费的空间,而且,线程间彼此切换所需的时间也远远小于进程间切换所需要 的时间. 使用多线程的理由之二是线

RabbitMQ五:生产者--队列--多消费者

一.生成者-队列-多消费者(前言) 上篇文章,我们做了一个简单的Demo,一个生产者对应一个消费者,本篇文章就介绍 生产者-队列-多个消费者,下面简单示意图 P 生产者    C 消费者  中间队列 需求背景:工厂某部门需要生产n个零件,部门下面有2个小组,每个小组需要生产n/2个 公平派遣 每个小组的情况下,当所有奇怪的信息都很重,甚至信息很轻的时候,一个工作人员将不断忙碌,另一个工作人员几乎不会做任何工作.那么,RabbitMQ不知道什么,还会平均分配消息. 这是因为当消息进入队列时,Rab

[golang] channel通道

说明 channel是go当中的一个核心类型,可以看做是管道.并发核心单元可以通过channel进行数据的发送和接收,从而实现通信. 在go中,channel是一种数据类型,主要被用来解决协程的同步问题以及协程之间数据共享(数据传递)的问题. go当中的goroutine运行在相同的地址空间,因此访问共享内存地址必须做好同步,goroutine奉行通过通信来共享内存,而不是共享内存来通信. 引用类型channel可用于多个goroutine通讯,在其内部实现了同步,确保并发安全. 定义chann

多个生产者——多个消费者模型(互斥量条件变量实现)

1. 介绍 生产者消费者问题属于有界缓冲区问题.我们现在讲述多个生产者向一个缓冲区中存入数据,多个生产者从缓冲区中取数据. 共享缓冲区作为一个环绕缓冲区,存数据到头时再从头开始. 2. 实现 我们使用一个互斥量保护生产者向缓冲区中存入数据. 由于有多个生产者,因此需要记住现在向缓冲区中存入的位置. 使用一个互斥量保护缓冲区中消息的数目,这个生产的数据数目作为生产者和消费者沟通的桥梁. 使用一个条件变量用于唤醒消费者.由于有多个消费者,同样消费者也需要记住每次取的位置. 4.代码 在选项中选择生产

Java多线程之生产者(Producer)和消费者(Consumer)

Producer生产者顾名思义就是生产数据的线程,Consumer消费者就是使用数据的线程.可以有多个生产者,也可以有多个消费者,当生产者和消费者都是一个的时候,又叫做管道Pipe Pattern. 下面简单写了个例子,一个线程加1,一个线程减1,一个生产者.一个消费者,生产者用来加1,消费者用来减1.下面代码已经验证ok. 1. Info数据对象,用来保存生产者和消费者使用的数据 public class Info { private int count; private boolean fl

golang 的 channel 实现 生产者/消费者 模型

package main import ( "fmt" "math/rand" "time" ) func productor(channel chan<- string) { for { channel <- fmt.Sprintf("%v", rand.Float64()) time.Sleep(time.Second * time.Duration(1)) } } func customer(channel

[JAVA 多线程] 生产者消费者实例

正好有人问,就直接将代码记录下来. 背景:有一个仓库存储货物,存在着生产者和消费者,设计一个可以并发的实现. 设计思路:设计一个仓库类,类中保存最大的容量限制和当前的count,类中包含生产和消费的方法,并且都是synchronized. 具体代码: package com.test.tiny; public class Store { private final int MAX_SIZE; //最大 private int count; // 当前 public Store(int n) {

黑马程序员-学习日记(生产者消费者实例)

1 class PCDemo 2 { 3 public static void main(String[] args) 4 { 5 Resource r = new Resource(); 6 Producer prd = new Producer(r); 7 Consumer csu = new Consumer(r); 8 9 Thread th0 = new Thread(prd); 10 Thread th1 = new Thread(prd); 11 Thread th2 = new

java生产者消费者实例

import java.util.Queue;import java.util.LinkedList;public class ProducerConsumerDemo { public static void main(String[] args) { MyQueue q = new MyQueue(); Producer p = new Producer(q); Consumer c = new Consumer(q); p.start(); c.start(); }}class Produ