How to stop listening on a server in Go

In the Go language, how to gracefully stop the listening server is a common problem. When we need to stop the server, we want to be able to gracefully close all connections without affecting requests being processed. This article will introduce several common methods to help you solve this problem. First, we can use a semaphore to control the shutdown of the server. The os package in Go language provides a Signal method that can be used to capture signals sent by the operating system. We can trigger the shutdown of the server by listening to the os.Interrupt signal, that is, Ctrl C. In the signal processing function, we can perform some cleanup work, such as closing the database connection, saving data, etc. Then, call the server's Shutdown method, which will wait for existing requests to be processed before shutting down the server. This way, we can gracefully stop the listening server. It is worth noting that if the server cannot be shut down within a certain period of time, we can use the WithTimeout method in the context package to set a timeout. After this time is exceeded, the server will be forced to shut down. Using this approach, we can ensure that the server shuts down gracefully under any circumstances. In addition to using semaphores, we can also use a bool type variable to control the shutdown of the server. When the server starts, we can define a global bool variable, such as isShutdown. Then, in the function that handles the request, we can check the value of this variable, and if it is true, return immediately and stop processing the current request. When shutting down the server, we set isShutdown to true and then wait for all requests to be processed before exiting the program. This method is relatively simple, but requires adding additional logic judgments to the function that handles the request, which may slightly affect performance. To sum up, whether using a semaphore or a bool variable, we can implement the function of gracefully stopping the listening server in the Go language. Which method to choose depends on your specific needs and the complexity of your project

Question content

I've been trying to find a way to gracefully stop a listening server in go. Because listen.accept blocks, it is necessary to close the listening socket to signal the end, but I can't differentiate between that error and any other errors because the related errors are not exported.

Can I do better? See serve() in the following code in fixme

package main

import (
    "io"
    "log"
    "net"
    "time"
)

// echo server struct
type echoserver struct {
    listen net.listener
    done   chan bool
}

// respond to incoming connection
//
// write the address connected to then echo
func (es *echoserver) respond(remote *net.tcpconn) {
    defer remote.close()
    _, err := io.copy(remote, remote)
    if err != nil {
        log.printf("error: %s", err)
    }
}

// listen for incoming connections
func (es *echoserver) serve() {
    for {
        conn, err := es.listen.accept()
        // fixme i'd like to detect "use of closed network connection" here
        // fixme but it isn't exported from net
        if err != nil {
            log.printf("accept failed: %v", err)
            break
        }
        go es.respond(conn.(*net.tcpconn))
    }
    es.done <- true
}

// stop the server by closing the listening listen
func (es *echoserver) stop() {
    es.listen.close()
    <-es.done
}

// make a new echo server
func newechoserver(address string) *echoserver {
    listen, err := net.listen("tcp", address)
    if err != nil {
        log.fatalf("failed to open listening socket: %s", err)
    }
    es := &echoserver{
        listen: listen,
        done:   make(chan bool),
    }
    go es.serve()
    return es
}

// main
func main() {
    log.println("starting echo server")
    es := newechoserver("127.0.0.1:18081")
    // run the server for 1 second
    time.sleep(1 * time.second)
    // close the server
    log.println("stopping echo server")
    es.stop()
}

This will print

2012/11/16 12:53:35 Starting echo server
2012/11/16 12:53:36 Stopping echo server
2012/11/16 12:53:36 Accept failed: accept tcp 127.0.0.1:18081: use of closed network connection

I want to hide the accept failed message, but obviously I don't want to cover up other errors that accept could be reported. I could of course look at the error test for use of closed network connection but that would be really ugly. I could set a flag to indicate that I'm about to close and ignore the error if it's set, I guess - is there a better way?

Workaround

Check for some "time to stop" flag in the loop after the accept() call and then flip it from main, Then connect to your listening port to get the server socket "without getting stuck". This is very similar to the old "self-pipeline trick".

The above is the detailed content of How to stop listening on a server in Go. For more information, please follow other related articles on the PHP Chinese website!