Golang中如何实现这个功能？

Golang中如何实现这个功能？ 大家好！我几天前开始学习Go语言，感到非常兴奋。我想请教一个关于并发的问题，不知道该如何解决。在这种情况下我的代码应该怎么写：

有四个不同的服务器，分别命名为"s1"、“s2”、“s3"和"s4”。我需要实现一个函数，向这四个服务器分别请求响应。该函数应该打印最先返回响应的服务器名称。服务器返回的具体内容不重要，可以是它自己的名称。

另外，我还需要实现一个类似的函数，但是如果服务器响应时间超过3秒，就应该打印错误信息。

感谢大家的关注，期待获得帮助。

3 回复

你好。这些服务器是"仅仅"监听同一通道的其他 Go 协程吗？还是指监听套接字的完整服务器？

更多关于Golang中如何实现这个功能？的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


这个示例怎么样？

package main

import (
	"fmt"
	"net/http"
	"time"
)

func main() {
	c := make(chan string)
	go func() {
		resp, err := http.Head("https://forum.golangbridge.org")
		if err == nil {
			resp.Body.Close()
			c <- resp.Status
			return
		}
		c <- "Failed to connect"
	}()

	// select status
	select {
		case status := <-c:
		fmt.Println(status)
		case <-time.After(3 * time.Second):
		fmt.Println("time is over")
	}
}

在Go语言中，可以使用goroutine和channel来实现并发请求，并使用select语句来捕获最先返回的响应。对于超时处理，可以利用context包或time.After来实现。以下是两个函数的实现示例：

1. 打印最先返回响应的服务器名称

这个函数使用goroutine并发请求四个服务器，并通过channel传递结果。select语句会等待第一个可用的响应。

package main

import (
    "fmt"
    "math/rand"
    "time"
)

// 模拟服务器请求，返回服务器名称
func requestServer(serverName string, ch chan<- string) {
    // 模拟随机响应时间（0到2秒）
    sleepTime := time.Duration(rand.Intn(2000)) * time.Millisecond
    time.Sleep(sleepTime)
    ch <- serverName
}

func printFirstResponse() {
    servers := []string{"s1", "s2", "s3", "s4"}
    ch := make(chan string, len(servers))

    // 启动goroutine并发请求每个服务器
    for _, server := range servers {
        go requestServer(server, ch)
    }

    // 等待第一个响应
    firstResponse := <-ch
    fmt.Printf("First response from: %s\n", firstResponse)
}

func main() {
    rand.Seed(time.Now().UnixNano())
    printFirstResponse()
}

2. 处理超时（超过3秒打印错误）

这个函数使用context.WithTimeout设置3秒超时，如果任何服务器在超时前响应，则打印其名称；否则打印超时错误。

package main

import (
    "context"
    "fmt"
    "math/rand"
    "time"
)

// 模拟服务器请求，可能随机超时
func requestServerWithTimeout(ctx context.Context, serverName string, ch chan<- string) {
    // 模拟随机响应时间（0到5秒，可能超过3秒）
    sleepTime := time.Duration(rand.Intn(5000)) * time.Millisecond
    select {
    case <-time.After(sleepTime):
        ch <- serverName
    case <-ctx.Done():
        // 如果上下文超时，直接返回而不发送
        return
    }
}

func printFirstResponseWithTimeout() {
    servers := []string{"s1", "s2", "s3", "s4"}
    ch := make(chan string, len(servers))
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    // 启动goroutine并发请求每个服务器
    for _, server := range servers {
        go requestServerWithTimeout(ctx, server, ch)
    }

    select {
    case firstResponse := <-ch:
        fmt.Printf("First response from: %s\n", firstResponse)
    case <-ctx.Done():
        fmt.Println("Error: request timeout exceeded 3 seconds")
    }
}

func main() {
    rand.Seed(time.Now().UnixNano())
    printFirstResponseWithTimeout()
}

说明

  • 在第一个函数中，requestServer模拟服务器响应，使用随机睡眠时间（0-2秒）来确保通常有服务器在3秒内响应。
  • 在第二个函数中，requestServerWithTimeout使用select监听上下文取消（超时）或正常响应。如果超时发生，主函数中的select会捕获ctx.Done()并打印错误。
  • 两个示例都使用了缓冲channel（容量为4）来避免goroutine泄漏，确保所有goroutine都能发送结果（即使不被接收）。
  • 在实际应用中，你可能需要替换requestServer函数中的模拟逻辑为真实的HTTP请求或其他I/O操作。

运行这些代码，你会看到第一个函数打印最先响应的服务器名称，而第二个函数在超时情况下会输出错误信息。

回到顶部