golang思考之运行速度之channel

最新推荐文章于 2020-12-10 07:28:43 发布
最新推荐文章于 2020-12-10 07:28:43 发布
阅读量229 收藏
点赞数
文章标签： golang 网络 c/c++
原文链接：https://my.oschina.net/u/1436705/blog/519583
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

golang channel测速程序：

package main

import (
    "runtime"
)

var PC_DATA_SIZE int 

var chEnd chan int 

func producer(ch chan byte) {
    for i := 0; i < PC_DATA_SIZE; i++ {
        ch <- 0
    }   
    chEnd <- 0
}

func consumer(ch chan byte) {
    for i := 0; i < PC_DATA_SIZE; i++ {
        <-ch
    }   
    chEnd <- 0
}

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    PC_DATA_SIZE = 10000000
    chEnd = make(chan int)
    ch := make(chan byte, 1024)
    go producer(ch)
    go consumer(ch)
    <-chEnd
    <-chEnd
}

C语言有锁并发队列：

#include <pthread.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#define PC_DATA_SIZE        10000000

typedef struct Queue{
    uint8_t *data;
    int front;
    int rear;
    int size;
    int maxSize;
    pthread_mutex_t mutex;
    pthread_cond_t empty;
    pthread_cond_t fill;
}Queue;

Queue *QueueInit(int maxSize){
    Queue *queue=malloc(sizeof(Queue));
    if(queue==NULL){
        perror("malloc");
        return NULL;
    }   
    queue->data=malloc(maxSize);
    if(queue->data==NULL){
        perror("malloc");
        free(queue);
        return NULL;
    }   
    queue->front=0;
    queue->rear=0;
    queue->size=0;
    queue->maxSize=maxSize;
    if(pthread_mutex_init(&queue->mutex,NULL)!=0){
        perror("pthread_mutex_init");
        return NULL;
    }
    if(pthread_cond_init(&queue->empty,NULL)!=0){
        perror("pthread_cond_init");
        return NULL;
    }
    if(pthread_cond_init(&queue->fill,NULL)!=0){
        perror("pthread_cond_init");
        return NULL;
    }
    return queue;
}

int QueueIn(Queue *queue,uint8_t data){
    if(pthread_mutex_lock(&queue->mutex)!=0){
        perror("pthread_mutex_lock");
        return -1;
    }
    while(queue->size==queue->maxSize){
        if(pthread_cond_wait(&queue->empty,&queue->mutex)!=0){
            perror("pthread_cond_wait");
            return -1;
        }
    }
    queue->data[queue->front]=data;
    ++queue->front;
    queue->front%=queue->maxSize;
    ++queue->size;
    if(pthread_cond_signal(&queue->fill)!=0){
        perror("pthread_cond_signal");
    }
    if(pthread_mutex_unlock(&queue->mutex)!=0){
        perror("pthread_mutex_unlock");
        return -1;
    }
    return 0;
}

int QueueOut(Queue *queue,uint8_t *data){
    if(pthread_mutex_lock(&queue->mutex)!=0){
        perror("pthread_mutex_lock");
        return -1;
    }
    while(queue->size==0){
        if(pthread_cond_wait(&queue->fill,&queue->mutex)!=0){
            perror("pthread_cond_wait");
            return -1;
        }
    }
    *data=queue->data[queue->rear];
    ++queue->rear;
    queue->rear%=queue->maxSize;
    --queue->size;
    if(pthread_cond_signal(&queue->empty)!=0){
        perror("pthread_cond_signal");
    }
    if(pthread_mutex_unlock(&queue->mutex)!=0){
        perror("pthread_mutex_unlock");
        return -1;
    }
    return 0;
}

void QueueDestroy(Queue *queue){
    if(pthread_cond_destroy(&queue->fill)!=0){
        perror("pthread_cond_destroy");
    }
    if(pthread_cond_destroy(&queue->empty)!=0){
        perror("pthread_cond_destroy");
    }
    if(pthread_mutex_destroy(&queue->mutex)!=0){
        perror("pthread_mutex_destroy");
    }
    free(queue->data);
    free(queue);
}

void *producerStart(void *arg){
    Queue *queue=(Queue*)arg;
    int64_t sum=0;
    int i;
    for(i=0;i<PC_DATA_SIZE;++i){
        uint8_t data=(uint8_t)i;
        if(QueueIn(queue,data)<0){
            perror("QueueIn");
            return NULL;
        }
        sum+=data;
    }
    printf("producerStart sum %ld\n",sum);
    return NULL;
}

void *consumerStart(void *arg){
    Queue *queue=(Queue*)arg;
    int64_t sum=0;
    int i;
    for(i=0;i<PC_DATA_SIZE;++i){
        uint8_t data;
        if(QueueOut(queue,&data)<0){
            perror("QueueOut");
            return NULL;
        }
        sum+=data;
    }
    printf("consumerStart sum %ld\n",sum);
    return NULL;
}

int main(void){
    Queue *queue=QueueInit(1024);
    if(queue==NULL){
        perror("QueueInit");
        return -1;
    }
    pthread_t producerTId;
    if(pthread_create(&producerTId,NULL,producerStart,queue)!=0){
        perror("pthread_create");
        return -1;
    }
    pthread_t consumerTId;
    if(pthread_create(&consumerTId,NULL,consumerStart,queue)!=0){
        perror("pthread_create");
        return -1;
    }
    pthread_join(producerTId,NULL);
    pthread_join(consumerTId,NULL);
    QueueDestroy(queue);
    return 0;
}

C语言无锁并发队列：

#include <pthread.h>
#include <semaphore.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#define PC_DATA_SIZE        10000000

typedef struct Queue{
    uint8_t *data;
    int front;
    int rear;
    int maxSize;
    sem_t empty;
    sem_t fill;
}Queue;

Queue *QueueInit(int maxSize){
    Queue *queue=malloc(sizeof(Queue));
    if(queue==NULL){
        perror("malloc");
        return NULL;
    }   
    queue->data=malloc(maxSize);
    if(queue->data==NULL){
        perror("malloc");
        free(queue);
        return NULL;
    }   
    queue->front=0;
    queue->rear=0;
    queue->maxSize=maxSize;
    if(sem_init(&queue->empty,0,queue->maxSize)<0){
        perror("sem_init");
        return NULL;
    }   
    if(sem_init(&queue->fill,0,0)<0){
        perror("sem_init");
        return NULL;
    }
    return queue;
}

int QueueIn(Queue *queue,uint8_t data){
    if(sem_wait(&queue->empty)<0){
        perror("sem_wait");
        return -1;
    }
    queue->data[queue->front]=data;
    ++queue->front;
    queue->front%=queue->maxSize;
    if(sem_post(&queue->fill)<0){
        perror("sem_post");
        return -1;
    }
    return 0;
}

int QueueOut(Queue *queue,uint8_t *data){
    if(sem_wait(&queue->fill)<0){
        perror("sem_wait");
        return -1;
    }
    *data=queue->data[queue->rear];
    ++queue->rear;
    queue->rear%=queue->maxSize;
    if(sem_post(&queue->empty)<0){
        perror("sem_post");
        return -1;
    }
    return 0;
}

void QueueDestroy(Queue *queue){
    if(sem_destroy(&queue->empty)<0){
        perror("sem_destroy");
    }
    if(sem_destroy(&queue->fill)<0){
        perror("sem_destroy");
    }
    free(queue->data);
    free(queue);
}

void *producerStart(void *arg){
    Queue *queue=(Queue*)arg;
    int64_t sum=0;
    int i;
    for(i=0;i<PC_DATA_SIZE;++i){
        uint8_t data=(uint8_t)i;
        if(QueueIn(queue,data)<0){
            perror("QueueIn");
            return NULL;
        }
        sum+=data;
    }
    printf("producerStart sum %ld\n",sum);
    return NULL;
}

void *consumerStart(void *arg){
    Queue *queue=(Queue*)arg;
    int64_t sum=0;
    int i;
    for(i=0;i<PC_DATA_SIZE;++i){
        uint8_t data;
        if(QueueOut(queue,&data)<0){
            perror("QueueOut");
            return NULL;
        }
        sum+=data;
    }
    printf("consumerStart sum %ld\n",sum);
    return NULL;
}

int main(void){
    Queue *queue=QueueInit(1024);
    if(queue==NULL){
        perror("QueueInit");
        return -1;
    }
    pthread_t producerTId;
    if(pthread_create(&producerTId,NULL,producerStart,queue)!=0){
        perror("pthread_create");
        return -1;
    }
    pthread_t consumerTId;
    if(pthread_create(&consumerTId,NULL,consumerStart,queue)!=0){
        perror("pthread_create");
        return -1;
    }
    pthread_join(producerTId,NULL);
    pthread_join(consumerTId,NULL);
    QueueDestroy(queue);
    return 0;
}

TCP：

dd if=/dev/zero of=send bs=10000 count=100000
nc -l 0.0.0.0 12345 > recv
time nc 127.0.0.1 12345 < send

速度：

                第一次测试        第二次测试        平均速度
golang             1.322s           1.301s        58.2Mbps
C有锁并发队列        3.693s           3.619s        20.9Mbps
C无锁并发队列        2.008s           1.767s        40.4Mbps
TCP                2.232s           2.213s        3433.0Mbps

测试暂时完成了，留下了很多问题：

1、为什么golang的channel比C语言快？如果C语言在内核态实现并发队列呢？

2、为什么TCP如此之快？

转载于:https://my.oschina.net/u/1436705/blog/519583

weixin_34291004
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
wifiwan口速率什么意思_【2K赞】为什么串行接口比并行接口快？
weixin_33657316的博客
12-31 284
编者注：偶尔会问一下工程师这个问题，其实蛮有意思的，有不少工程师还是不清楚这个问题，至少是没有认真想过这个问题的人可能真不知道怎么回答。本文回答了这个问题，但是有一些观点还是值得商榷，可以把本文当一篇小短文看看吧，作者的回答获得了2000多人的赞，还是有一定的道理的，因为回答是2015年的，所以有的内容自己懂就好了。本文是整理自知乎的内容，本文内容主要由：龚黎明、又见山人两位回答的。原文...
golang-goroutine与channel:高效的channel
changjixiong的专栏
08-29 4828
golang有两个非常大的特性，那就是goruntime与channel，这两个特性直接将开发人员从并发和线程同步中解放了出来，使高并发和线程同步之间代码的编写变得异常简单，并且占用资源少，同步传输效率高。         资源占用方面，goroutine 会从4096字节的初始栈内存占用开始按需增长或缩减内存占用。同步传输效率方面，我曾经在松本行弘的《代码的未来》一书上看到一个简洁的例子(
Go channel到底有多快 | Gopher Daily (2020.07.06) ʕ◔ϖ◔ʔ
TonyBai
07-06 209
每日一谚：The standard library is a great place to find good Go code.gopherdaily归档库在github上的星星数量已经...
golang常用编程组件效率统计
vipally的专栏
11-06 1849
序号 运行项 耗时 每次 1 go empty_loop 0 0 2 go empty_func 0 0 3 go with ret 0 0 4 no_sync_rand 0 0 5 spin lock rand 31.25ms
golang channel阻塞问题解决
热门推荐
xiangxianghehe的博客
10-22 1万+
先看一段会死锁的代码：package mainimport ( "fmt" )func f1(in chan int) { fmt.Println(<-in) }func main() { out := make(chan int) out <- 2 go f1(out) }单纯的out<-和<-in都会阻塞，只有两个同时进行了，才能继续执行。 这里你看上去
基于golang channel实现的轻量级异步任务分发器示例代码
09-20
在Golang中，Channel是并发编程的核心特性之一，它提供了在不同的goroutine之间安全地传递数据的能力。在本文中，我们将深入探讨如何使用Golang Channel实现一个轻量级的异步任务分发器，以便更好地理解和应用这一...
golang1.19.3
11-13
- `golang1.19.3` 可能包含了一系列的性能优化，比如编译速度的加快、运行时性能的提升，或者特定场景下代码执行速度的提高。 5. **安全性和稳定性**： - 修复了先前版本中的安全漏洞，确保了使用 Go 语言开发的...
golang多线程爬虫
07-19
在这个项目中，每个goroutine可能负责一个网页的抓取和解析，这样可以同时处理多个URL，显著提高爬虫的抓取速度。Channel则是goroutine间通信的关键工具，用于在不同的并发单元之间传递数据，保证数据的安全性和正确...
Golang 搭建 Web 聊天室
06-07
【Golang 搭建 Web 聊天室】是一个关于使用 Go 语言构建实时通信应用的教程，重点是利用 WebSocket 协议实现一个在线聊天室。WebSocket 是一种在 Web 端支持双向通信的协议，它克服了 HTTP 的单向传输限制，允许...
基于Golang的分布式爬虫管理平台
最新发布
04-08
在分布式爬虫场景中，Golang的goroutine和channel机制使得并发处理数据请求变得简单且高效，能够轻松地处理大量的网络连接和并发任务。 2. **分布式系统**：分布式爬虫管理平台的核心是其分布式架构，这使得它可以...
深入学习golang(2)—channel
weixin_34278190的博客
10-02 3350
Channel 1. 概述 “网络，并发”是Go语言的两大feature。Go语言号称“互联网的C语言”，与使用传统的C语言相比，写一个Server所使用的代码更少，也更简单。写一个Server除了网络，另外就是并发，相对python等其它语言，Go对并发支持使得它有更好的性能。 Goroutine和channel是Go在“并发”方面两个核心feature。 Channel是goro...
golang的channel和条件变量在单生产单消费场景下的性能对比测试
q191201771的专栏
04-18 1344
本篇文章同步发布于：golang的channel和条件变量在单生产单消费场景下的性能对比测试 | yoko blog 本文相应的代码附在文章末尾处。 场景描述 1个生产者只与1个消费者相互绑定。 生产者按固定生产频率，每间隔<PRODUCE_INTERVAL_MS>毫秒生产一个任务。 生产者每次生产时都检查当前任务队列大小，如果已经超过<QUEUE_NUM_CANCEL_PRO...
Golang之Channel的理解与应用
Erick Lv的笔记
08-21 1883
博客参考自：https://golangbot.com/buffered-channels-worker-pools/ 基础应用 使用channel的阻塞性质作为延时函数。 package main import ( &amp;quot;fmt&amp;quot; ) func hello(done chan bool) { fmt.Println(&amp;quot;Hello world goroutine !&amp;quot;) ...
进程 线程 协程 之间的定义
weixin_30666753的博客
05-31 245
　1、进程 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。每个进程都有自己的独立内存空间，不同进程通过进程间通信来通信。由于进程比较重量，占据独立的内存，所以上下文进程间的切换开销（栈、寄存器、虚拟内存、文件句柄等）比较大，但相对比较稳定安全。 　　2、线程 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立...
go channel 缓冲区最大限制_分享go的channel两篇文章（1）
weixin_30556403的博客
12-10 950
本文翻译自Channels In GoChannel是Go中一个重要的内置功能。这是让Go独一无二的功能之一，除了另一个独特的功能，goroutine。这两个独特的功能使Go中的并发编程变得非常方便和有趣，这两个特性降低了并发编程的难度。本文将列出所有与channel相关的概念，语法和准则。为了更好地理解channel，还简单描述了channel的内部结构和标准Go编译器/运行时的一些实...
GoLang Channel与mutex的选择，性能差不多
toontong的专栏
11-17 5397
go官方应该是更推荐使用chan https://github.com/golang/go/wiki/MutexOrChannel以下代码用于测试性能 — 不确保思路是正确的。package mainimport ( "fmt" "sync" "time" )type Op struct { key int val int }var lock sync.Mu
go 锁 速度 chan 和 mutex的比较
weixin_30437481的博客
07-30 651
package main import ( "fmt" "sync" "time" ) func main() { start := time.Now() mu := sync.Mutex{} for i := 0; i < 1000000; { mu.Lock() i++ mu.Unlock() } fmt.Println...
Golang中 goroutine执行速度的问题
Lazyboy_的博客
04-14 822
突然想到了之前一直没留意的for循环中开goroutine的执行顺序问题，就找了段代码试了试，试了几次后发现几个有意思的地方，我暂时没有精力往更深处挖掘，希望有golang大神能简单说一说这几个地方是怎么回事。 代码： package main import "fmt" func Count(ch chan int) { fmt.Println("Count doing") c...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值