golang并发http请求几种方式

最新推荐文章于 2024-05-02 09:30:59 发布
最新推荐文章于 2024-05-02 09:30:59 发布
阅读量2w 收藏 38
点赞数 14
分类专栏： Go 文章标签： golang go 协程 并发编程 http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37422289/article/details/105328796
版权

概述

go中方便的协程写法, 让并发变得很简单, 让开发者很多时候不需要关心协程(线程)管理的问题, 不过也是有值得注意的地方.
下面以一个http请求的例子, 请求的服务是进制数据-手机号码归属地查询.(找了很久才找到方便学demo的免费API, 想跑demo的朋友注册一下在代码中填上自己的appkey即可)

并发方式

平时常用到3种方式做并发请求.

  1. 简单粗暴, 一次请求开一个线程, 线程中完成请求与响应处理.
  2. 优雅一点, 限制线程池, 以master-worker的方式处理并发, 最后又把响应统一处理.
  3. 优雅地限制线程池(2020.7.15更新)

1. 简单并发

代码

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"sync"
	"time"
)
func main()  {
	var numberTasks = [5]string{"13456755448", " 13419385751", "13419317885", " 13434343439","13438522395"}
	client = &http.Client{}
	beg := time.Now()
	wg := &sync.WaitGroup{}
	for _, keyword := range numberTasks{
		wg.Add(1)
		go func(keyword string, group *sync.WaitGroup) {
			body, err := NumberQueryRequest(keyword)
			if err != nil{
				fmt.Printf("error occurred in query keyword: %s, error: %s\n",keyword, err.Error() )
			}else{
				fmt.Printf("search %s success, data size is %d\n, body is %s\n",keyword, len(body), string(body))
			}
			group.Done()
		}(keyword, wg)
	}
	wg.Wait() //waitGroup在主线程等待所有任务完成
	fmt.Printf("time consumed: %fs", time.Now().Sub(beg).Seconds())
}

var client *http.Client

//GET请求的通用写法, 注意复用client即可.
func NumberQueryRequest(keyword string)(body []byte, err error){
	url := fmt.Sprintf("https://api.binstd.com/shouji/query?appkey=df2720f76a0991fa&shouji=%s", keyword)
	req, err := http.NewRequest("GET", url, nil)
	if err != nil{
		return nil, err
	}
	resp, err := client.Get(url)
	if err != nil{
		return nil, err
	}
	if resp.StatusCode != http.StatusOK{
		data, _ := ioutil.ReadAll(resp.Body)
		return nil, fmt.Errorf("response status code is not OK, response code is %d, body:%s", resp.StatusCode, string(data))
	}
	if resp != nil && resp.Body != nil{
		defer resp.Body.Close()
	}
	body, err = ioutil.ReadAll(resp.Body)
	if err != nil{
		return nil, err
	}
	return body, nil
}

解析

  • 在for循环中有多少个任务就go出去多少个协程,没有限制,在查询量固定或者不大的时候没什么问题.
  • 没有用到 channel的特性, 仅利用了多核调度.

2. master-worker形式

代码

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"sync"
	"time"
)
const (
	routineCountTotal = 5 //限制线程数
)

func main() {
	var numberTasks = [5]string{"13456755448", " 13419385751", "13419317885", " 13434343439", "13438522395"}
	client = &http.Client{}
	beg := time.Now()
	wg := &sync.WaitGroup{}
	tasks := make(chan string)
	results := make(chan string)
	//receiver接受响应并处理的函数块, 也可以单独写在一个函数
	go func() {
		for result := range results{
			if result == ""{
				close(results)
			}else{
				fmt.Println("result:", result)
			}
		}
	}()
	for i:= 0; i < routineCountTotal; i++{
		wg.Add(1)
		go worker(wg, tasks, results)
	}
	//分发任务
	for _, task := range numberTasks{
		tasks <- task
	}
	tasks <- "" //worker结束标志
	wg.Wait() //同步结束
	results <- "" // result结束标志
	fmt.Printf("time consumed: %fs", time.Now().Sub(beg).Seconds())
}

func worker(group *sync.WaitGroup, tasks chan string, result chan string){
	for task := range tasks{
		if task == ""{
			close(tasks)
		}else{
			respBody, err := NumberQueryRequest(task)
			if err != nil{
				fmt.Printf("error occurred in NumberQueryRequest: %s\n", task)
				result <- err.Error()
			}else{
				result <- string(respBody)
			}
		}
	}
	group.Done()
}

var client *http.Client

func NumberQueryRequest(keyword string) (body []byte, err error) {
	url := fmt.Sprintf("https://api.binstd.com/shouji/query?appkey=df2720f76a0991fa&shouji=%s", keyword)
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36")
	resp, err := client.Get(url)
	if err != nil {
		return nil, err
	}
	if resp.StatusCode != http.StatusOK {
		data, _ := ioutil.ReadAll(resp.Body)
		return nil, fmt.Errorf("response status code is not OK, response code is %d, body:%s", resp.StatusCode, string(data))
	}
	if resp != nil && resp.Body != nil {
		defer resp.Body.Close()
	}
	body, err = ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	return body, nil
}

输出

result: {"status":0,"msg":"ok","result":{"shouji":"13434343439","province":"广东","city":"广州","company":"中国移动","cardtype":null,"areacode":"020"}}
result: {"status":0,"msg":"ok","result":{"shouji":"13438522395","province":"四川","city":"攀枝花","company":"中国移动","cardtype":null,"areacode":"0812"}}
result: {"status":0,"msg":"ok","result":{"shouji":"13419317885","province":"四川","city":"广安","company":"中国移动","cardtype":null,"areacode":"0826"}}
result: {"status":0,"msg":"ok","result":{"shouji":"13456755448","province":"浙江","city":"杭州","company":"中国移动","cardtype":null,"areacode":"0571"}}
result: {"status":0,"msg":"ok","result":{"shouji":"13419385751","province":"四川","city":"遂宁","company":"中国移动","cardtype":null,"areacode":"0825"}}
time consumed: 0.399975s

3. 使用带缓冲区的chan控制

完整代码见: https://github.com/chrispinkyang/golimitDemo

先上代码

package golimit

type Glimit struct {
	Num int
	C   chan struct{}
}

func NewG(num int) *Glimit {
	return &Glimit{
		Num: num,
		C : make(chan struct{}, num),
	}
}

func (g *Glimit) Run(f func()){
	g.C <- struct{}{}
	go func() {
		f()
		<-g.C
	}()
}

使用方式

func main() {
	number := 10
	// 限制线程数2
	g := NewG(2)
	wg := sync.WaitGroup{}
	for i := 0; i < number; i++ {
		wg.Add(1)
		value :=i // 闭包传值方式
		goFunc := func() {
			// 做一些业务逻辑处理
			fmt.Printf("go func: %d\n", value)
			time.Sleep(time.Second)
			wg.Done()
		}
		g.Run(goFunc)
	}
	wg.Wait()
}

并发请求的用法

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"sync"
	"time"
	"./golimit"
)

const (
	routineCountTotal = 5 //限制线程数
)

func main() {
	var numberTasks = [5]string{"13456755448", " 13419385751", "13419317885", " 13434343439", "13438522395"}

	g := golimit.NewG(routineCountTotal)
	wg := &sync.WaitGroup{}
	client = &http.Client{}
	beg := time.Now()
	for i := 0; i < len(numberTasks); i++ {
		wg.Add(1)
		task := numberTasks[i]
		g.Run(func() {
			respBody, err := NumberQueryRequest(task)
			if err != nil {
				fmt.Printf("error occurred in NumberQueryRequest: %s\n", task)
			} else {
				fmt.Printf("response data: %s\n", string(respBody))
			}
			wg.Done()
		})
	}
	wg.Wait()
	fmt.Printf("time consumed: %fs", time.Now().Sub(beg).Seconds())
}
var client *http.Client

func NumberQueryRequest(keyword string) (body []byte, err error) {
	url := fmt.Sprintf("https://api.binstd.com/shouji/query?appkey=df2720f76a0991fa&shouji=%s", keyword)
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36")
	resp, err := client.Get(url)
	if err != nil {
		return nil, err
	}
	if resp.StatusCode != http.StatusOK {
		data, _ := ioutil.ReadAll(resp.Body)
		return nil, fmt.Errorf("response status code is not OK, response code is %d, body:%s", resp.StatusCode, string(data))
	}
	if resp != nil && resp.Body != nil {
		defer resp.Body.Close()
	}
	body, err = ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	return body, nil
}

输出

response data: {"status":0,"msg":"ok","result":{"shouji":"13456755448","province":"浙江","city":"杭州","company":"中国移动","cardtype":null,"areacode":"0571"}}
response data: {"status":0,"msg":"ok","result":{"shouji":"13438522395","province":"四川","city":"攀枝花","company":"中国移动","cardtype":null,"areacode":"0812"}}
response data: {"status":0,"msg":"ok","result":{"shouji":"13434343439","province":"广东","city":"广州","company":"中国移动","cardtype":null,"areacode":"020"}}
response data: {"status":0,"msg":"ok","result":{"shouji":"13419385751","province":"四川","city":"遂宁","company":"中国移动","cardtype":null,"areacode":"0825"}}
response data: {"status":0,"msg":"ok","result":{"shouji":"13419317885","province":"四川","city":"广安","company":"中国移动","cardtype":null,"areacode":"0826"}}
time consumed: 0.937952s%

解析

  • 比第一种方式更规范一些, 线程数量可以控制.
  • 两处close通道的地方都用了传特殊空值的方式, 似乎不太优雅, 欢迎有更好的关闭通道的方式互相交流, 谢谢.

第三种方式解析(2020.7.15更新)

  • 巧妙地使用go带缓冲区的通道来实现goroutine控制, 更加简洁, 并且这种方式在多个项目中都可以复用. 不必像第二种方式一样每次都实现一个worker函数.

参考

Go开发中，如何有效控制Goroutine的并发数量

chrispink_yang
关注
  • 14
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang实现请求限流的几种办法(小结)
09-18
在Golang中，请求限流是一种关键的技术，用于保护系统免受过高的并发请求压力，防止资源耗尽，保证服务的稳定性和可用性。本文将深入探讨几种实现请求限流的方法，并通过示例代码进行详细解释。 1. 利用Channel的...
golang + vue 低仿微信
04-15
5. **并发处理**：Go语言的协程（Goroutine）和通道（Channel）机制使得处理大量并发请求变得高效且易于管理，尤其适合高并发的聊天服务。 ### Vue.js Vue.js是一个轻量级的前端JavaScript框架，用于构建用户界面。...
深度探讨 Golang 中并发发送 HTTP 请求的最佳技术
m0_68662723的博客
01-21 6504
总之，本文探讨了在 Golang 中并发发送 HTTP 请求的各种方法，这是优化 Web 应用程序的一项关键技能。我们已经讨论了基本的 goroutine、sync.WaitGroup、通道、工作池以及限制 goroutine 的方法。每种方法都有其独特的特点，可以根据特定的应用要求进行选择。此外，本文还强调了并发 Go 程序中错误处理的重要性。管理并发环境中的错误可能具有挑战性，但对于构建健壮的应用程序至关重要。
golang http库的使用 并发 get post请求处理
weixin_44846765的博客
06-21 1946
golang http库的使用 并发 get post请求处理
HTTP协议如何处理并发请求？
最新发布
长风破浪会有时的博客
05-02 315
HTTP协议是基于TCP协议的，而TCP协议是可靠的，它通过建立连接来确保数据的传输。当客户端（比如你的电脑）想要同时发送多个请求时，它会建立多个TCP连接，每个连接负责传输一个请求。需要注意的是，虽然HTTP协议可以处理并发请求，但是服务器的处理能力是有限的。因此，在实际应用中，我们需要合理地控制并发请求的数量，以确保服务器的稳定运行。想象一下，你在家里同时打开了几个水龙头，这些水龙头都在同时放水，这就是“并发”。在计算机网络里，“并发请求”就是同时发送多个请求到服务器，要求服务器同时处理这些请求。
Go语言中的HTTP请求和响应处理
weixin_73725158的博客
01-04 763
Go语言，作为一种高效且现代的编程语言，为开发者提供了简洁、强大的工具来处理HTTP请求和响应。总之，Go语言通过其简洁而强大的标准库为开发者提供了方便的工具来处理HTTP请求和响应。通过这个方法，我们可以将之前创建的请求对象发送出去，并得到一个响应对象。这个包为开发者提供了发送HTTP请求、接收HTTP响应、解析请求数据以及构建响应数据的功能。接收到响应后，我们可以使用响应对象的方法来获取响应的各种信息，如状态码、响应头、响应体等。而对于POST请求，请求数据则通常包含在请求体中，可以使用。
使用Go语言的HTTP客户端进行并发请求
weixin_73725158的博客
01-05 765
首先，让我们了解为什么需要并发HTTP请求。在许多应用场景中，我们可能需要同时向多个URL发起请求，例如同时获取多个页面的内容、从多个API获取数据等。通过并发请求，我们可以显著提高应用的响应速度和吞吐量。在Go中，标准库提供了强大的HTTP客户端和服务器功能，使得并发HTTP请求变得简单而高效。通过这种方式，我们可以轻松地并发发送多个HTTP请求，并等待它们全部完成。请注意，这只是一个简单的示例，实际应用中可能需要更多的错误处理和逻辑处理。在上述示例中，我们首先定义了一个包含URL的字符串切片。
golang并发执行的几种方式
阿十爸爸的博客
03-16 1103
假设有一批url，需要并发去抓取，这个时候可能只是请求的地址不同，任务的函数是一致的。使用该方法时候，需要使用线程安全的结构去做数据同步。此外下文的写法最大的弊端是没法做并发度控制，如果请求过多，容易把下游打满，以及启过多协程，浪费资源，只适合小数据集，需要注意的是，我们在并发度通道中使用了一个空结构体{}，因为我们只需要通道来控制并发度，而不需要在通道中传递任何数据。此外，我们还使用了通道的阻塞特性来控制并发度，因为当通道已满时，任何试图向通道中发送数据的操作都会被阻塞，直到有空间可用为止。
Golang你一定要懂的连接池实现
09-16
在Golang中，连接池是一种优化数据库或其他网络资源访问效率的机制。它通过预先创建并维护一定数量的连接，使得应用程序在需要时可以快速获取到连接，而不必每次请求时都进行新的连接建立，从而降低了连接创建和销毁...
golang爬虫库
07-07
在IT领域，Go语言（Golang）以其高效、简洁的语法和强大的并发能力，成为构建网络服务和系统工具的热门选择。"golang爬虫库"是指使用Go语言编写的用于网页抓取和数据提取的工具集合。这些库通常包含了处理HTTP请求、...
使用Golang简单实现七牛图片处理API
09-21
在本文中，我们将探讨如何使用Golang来简单实现七牛图片处理API，主要涉及以下几个关键知识点： 1. **七牛云存储与图片处理API**： 七牛云存储提供了一套丰富的图片处理服务，包括但不限于图片缩略、裁剪、旋转、...
Go语言net/http包使用详细介绍
肥叔菌的博客
12-20 3246
Go的http有两个核心功能：Conn、ServeMux（多路复用器） Go 提供了一系列用于创建 Web 服务器的标准库，而且通过 Go 创建一个服务器的 步骤非常简单，只要通过 net/http 包调用 ListenAndServe 函数并传入网络地址以及负责处理请求的处理器( handler )作为参数就可以了。如果网络地址参数为空字符串，那 么服务器默认使用 80 端口进行网络连接；如果处理器参数为 nil，那么服务器将使用默认的多路复用器 DefaultServeMux。Conn的goroutin
Go 语言 HTTP 请求处理的底层机制
weixin_42128977的博客
08-13 680
1.web 工作方式的几个概念 Request：用户请求的信息，用来解析用户的请求信息，包括 post、get、cookie、url 等信息 Response：服务器需要反馈给客户端的信息 Conn：用户的每次请求链接 Handler：处理请求和生成返回信息的处理逻辑 2.工作流程 1.创建ListenSocket,监听指定的端口，等待客户端请求到来。(如何去监听端口) 2.ListenSocket接受客户端的请求，得到ClientSocket,接下来通过ClientSoc...
golang 异步并发http轮询（爬虫）
bushuwei的博客
11-21 1849
工作中总会用到密集http查询，我们采用异步+并发的策略，看看golang是怎么实现的吧
Golang适合高并发场景的原因分析
热门推荐
蝈蝈俊.net
06-01 8万+
典型的两个现实案例： 我们先看两个用Go做消息推送的案例实际处理能力。 360消息推送的数据： 16台机器，标配：24个硬件线程，64GB内存 Linux Kernel 2.6.32 x86_64 单机80万并发连接，load 0.2~0.4，CPU 总使用率 7%~10%，内存占用20GB (res) 目前接入的产品约1280万在线用户 2分钟一次GC，停顿2
golang中发送http请求的几种常见情况
diemoyi5954的博客
07-19 1227
整理一下golang中各种http的发送方式 最初的一些项目中，很多的地方都使用到了golang发送http请求，之后再对请求收到的结果进行一些处理，所用到的模式也比较固定，这里整理一下集中http的发送方式，先记录这么多，再一点一点添加。 最基本的场景 方式一 使用http.Newrequest 先生成http.client -> 再生成 http.request -> 之...
Golang百万级高并发实践
Jeanphorn的专栏
01-09 3万+
写在前面Go语言作为新兴的语言，最近发展势头很是迅猛，其最大的特点就是原生支持并发。它使用的是“协程（goroutine）模型”，和传统基于 OS 线程和进程实现不同，Go 语言的并发是基于用户态的并发，这种并发方式就变得非常轻量，能够轻松运行几万并发逻辑。Go 的并发属于 CSP 并发模型的一种实现，CSP 并发模型的核心概念是：“不要通过共享内存来通信，而应该通 过通信来共享内存”。这在 G
Go-简洁的并发
Linvo's blog
11-30 4471
多核处理器越来越普及。有没有一种简单的办法，能够让我们写的软件释放多核的威力？是有的。随着Golang, Erlang, Scale等为并发设计的程序语言的兴起，新的并发模式逐渐清晰。正如过程式编程和面向对象一样，一个好的编程模式有一个极其简洁的内核，还有在此之上丰富的外延。可以解决现实世界中各种各样的问题。本文以GO语言为例，解释其中内核、外延。 并发模式之内核 这种并发模式的内核只
golang 短信通道
09-16
Golang 短信通道是使用 Go 语言开发的一种用于发送短信的通信工具。在现代社会中，短信通道是一种非常重要和常用的通信方式，它不仅可以用于个人之间的短信互通，还用于企业之间或企业与用户之间的信息传递。 使用 Golang 进行短信通道的开发具有以下几个优点： 1. 快速高效：Go 语言是一种编译型语言，具有非常高的执行效率和处理速度。在短信通道中，高效的执行速度和处理能力可以确保短信的及时发送和接收，保证通信的实时性。 2. 并发支持：Go 语言内置并发机制，使用轻量级的 goroutine 和通道(channel) 可以很方便地实现并发操作。在短信通道中，这种并发支持可以同时处理多个短信请求，提高短信的发送速度和通道的处理能力。 3. 代码简洁易读：Go 语言注重代码的简洁性和可读性，在语法设计上追求简单清晰。使用 Go 语言进行短信通道的开发，代码量相对较少，易于维护和理解。 4. 跨平台兼容：Go 语言的编译器能够生成可执行文件，使得开发的应用程序可以在不同的操作系统平台上运行。这样，使用 Golang 开发的短信通道可以在多个平台上使用，提高了通信的灵活性和可用性。 总的来说，Golang 短信通道是一种高效、可靠、并发支持的通信工具，在各种应用场景中都能展现出良好的性能和稳定性。它不仅可以用于个人之间的短信交流，还广泛应用于企业之间的业务通信和各种机构与用户之间的信息传递中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值