很多时候在 Go 中开发 http 服务器时,我遇到了这个困境。
假设我想尽快回复客户http statuscode 200(然后在后面执行工作),这就是我通常这样做的原因:
我让我的主要 http 处理程序接收请求,我写http 200响应,然后我通过 a 发送一条消息channel(如果我有N工作人员在听channel,我正在使用 a buffered channelof N):
func myHttpHandler(rw http.ResponseWriter, req *http.Request) {
rw.WriteHeader(200)
log(req)
}
func log(req *http.Request) {
msg := createLog(req)
if msg != nil {
channel <- msg
}
}
Run Code Online (Sandbox Code Playgroud)
我让我的听众(在 init 上被解雇)永远在那个频道上听:
func init() {
for i := 0; i < workerCount; i++ {
go worker(i, maxEntrySize, maxBufferSize, maxBufferTime)
}
}
func worker(workerID …Run Code Online (Sandbox Code Playgroud) 我不明白为什么在这段代码中发生了死锁.我尝试了几种不同的东西来阻止僵局(使用WorkGroup的几个不同版本).这是我在Go的第一天,到目前为止我对相当简单和直接的操作的复杂性感到非常失望.我觉得我错过了一些大而明显的东西,但是我发现的所有文档看起来都非常不同于我,这是一种非常基本的操作模式.所有文档都使用基本类型的通道(int,string)而不是更复杂的类型,所有类型都具有非常基本的for循环或者它们位于频谱的另一端,其中函数是相当复杂的编排.
我想我正在寻找一个中间的道路样本"这就是它通常如何做"与goroutines.
package main
import "fmt"
//import "sync"
import "time"
type Item struct {
name string
}
type Truck struct {
Cargo []Item
name string
}
func UnloadTrucks(c chan Truck) {
for t := range c {
fmt.Printf("%s has %d items in cargo: %s\n", t.name, len(t.Cargo), t.Cargo[0].name)
}
}
func main() {
trucks := make([]Truck, 2)
ch := make(chan Truck)
for i, _ := range trucks {
trucks[i].name = fmt.Sprintf("Truck %d", i+1)
fmt.Printf("Building %s\n", trucks[i].name)
}
for t := range …Run Code Online (Sandbox Code Playgroud) 我正在尝试了解通道和 goroutines 并尝试编写一个 goroutine 来向服务器发出并发 API 请求
但是当我使用 goroutine 运行代码时,它似乎花费了与没有 goroutine 相同的时间。
func sendUser(user string, ch chan<- string) {
resp,err := http.get("URL"/user)
//do the processing and get resp=string
ch <- resp
}
func AsyncHTTP(users []string) ([]string, error) {
ch := make(chan string)
var responses []string
var user string
for _ , user = range users {
go sendUser(user, ch)
for {
select {
case r := <-ch:
if r.err != nil {
fmt.Println(r.err)
}
responses = append(responses, r)
**//Is there …Run Code Online (Sandbox Code Playgroud) package main
import (
"fmt"
"time"
)
type field struct {
name string
}
func (p *field) print() {
fmt.Println(p.name)
}
func main() {
data := []field{ {"one"},{"two"},{"three"} }
for _,v := range data {
go v.print()
}
<-time.After(1 * time.Second)
}
Run Code Online (Sandbox Code Playgroud)
为什么此代码以任何顺序打印 3 “三”而不是“一”“二”“三”?
我目前有一个 Go 代码,可以订阅和打印发布到某个主题的传感器数据。这是我的代码:
package main
import (
"crypto/tls"
"flag"
"fmt"
//"log"
"os"
"os/signal"
"strconv"
"syscall"
"time"
MQTT "github.com/eclipse/paho.mqtt.golang"
)
func onMessageReceived(client MQTT.Client, message MQTT.Message) {
//fmt.Printf("Received message on topic: %s\nMessage: %s\n", message.Topic(), message.Payload())
fmt.Printf("%s\n", message.Payload())
}
func main() {
//MQTT.DEBUG = log.New(os.Stdout, "", 0)
//MQTT.ERROR = log.New(os.Stdout, "", 0)
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
hostname, _ := os.Hostname()
server := flag.String("server", "tcp://test.mosquitto.org:1883", "The full url of the MQTT server to connect to ex: tcp://127.0.0.1:1883")
topic := flag.String("topic", …Run Code Online (Sandbox Code Playgroud) 如果我有多个 go 例程同时添加和调用 done 到一个等待组。从并发的角度来看,这安全吗?我见过的大多数等待组示例都将添加保留在调用/创建其他程序的单个 go 例程中。
我需要从多个 go 例程中获取响应并将它们放入一个数组中。我知道可以为此使用通道,但是我不确定如何确保所有 go 例程都完成了对结果的处理。因此我使用了一个等待组。
代码
func main() {
log.Info("Collecting ints")
var results []int32
for _, broker := range e.BrokersByBrokerID {
wg.Add(1)
go getInt32(&wg)
}
wg.Wait()
log.info("Collected")
}
func getInt32(wg *sync.WaitGroup) (int32, error) {
defer wg.Done()
// Just to show that this method may just return an error and no int32
err := broker.Open(config)
if err != nil && err != sarama.ErrAlreadyConnected {
return 0, fmt.Errorf("Cannot connect to broker '%v': %s", broker.ID(), err)
}
defer broker.Close()
return 1003, nil
} …Run Code Online (Sandbox Code Playgroud) 我正在构建将创建大量线程的应用程序。每个线程将连接到不同的远程服务器,并且每个线程必须始终与其服务器通信。
在我使用之前PHP,对于这样的目标来说,这是一个糟糕的解决方案。我认为本机线程如何工作:例如,我们在单核上有 100 个线程。核心将在所有线程之间分配它的工作时间。
从我阅读和理解的内容来看:
如果我打开很多goroutines,一个goroutine可以阻止其他人的执行goroutines。在特定情况下(可能在当前goroutine睡眠或类似情况下)执行将传递给其他人。但它不像本地线程那样工作。
我需要让所有线程都能流畅地执行。就像每个goroutine. 我不需要一些goroutine被执行很长时间而其他人会等待..
我可以实现它golang吗?或者更好地使用另一种语言(哪一种)?
我需要运行请求parallel而不是一个接一个,而是超时。现在我可以在 go 中完成吗?
这是我需要并行运行的特定代码,这里的技巧也是使用超时,即根据超时等待所有请求并在完成后获取响应。
for _, test := range testers {
checker := NewTap(test.name, test.url, test.timeout)
res, err := checker.Check()
if err != nil {
fmt.Println(err)
}
fmt.Println(res.name)
fmt.Println(res.res.StatusCode)
}
Run Code Online (Sandbox Code Playgroud)
这是所有代码(工作代码) https://play.golang.org/p/cXnJJ6PW_CF
package main
import (
`fmt`
`net/http`
`time`
)
type HT interface {
Name() string
Check() (*testerResponse, error)
}
type testerResponse struct {
name string
res http.Response
}
type Tap struct {
url string
name string
timeout time.Duration
client *http.Client
}
func NewTap(name, url string, …Run Code Online (Sandbox Code Playgroud) 我有一个类似于How to stop a goroutine with a small twist的问题。我不确定 goroutine 是否正在运行。
var quit = make(chan bool)
func f1() {
go func() {
t := time.NewTimer(time.Minute)
select {
case <-t.C:
// Do stuff
case <-quit:
return
}
}()
}
func f2() {
quit <- true
}
Run Code Online (Sandbox Code Playgroud)
如果f2()在 之后不到一分钟被调用f1(),则 goroutine 返回。但是,如果它在一分钟后被调用,goroutine 将已经返回并f2()会阻塞。f2()如果 goroutine 正在运行,我想取消它,否则什么都不做。
我在这里试图实现的是当且仅当它在创建后的一分钟内没有被取消时才执行任务。
说明:
f2()被多次调用的。f1()将确保每分钟调用它的次数不会超过一次。