Creating a Multithreaded Server with Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setting Up the Project
  4. Creating the Server
  5. Handling Concurrent Connections
  6. Testing the Server
  7. Conclusion

Introduction

In this tutorial, we will learn how to create a multithreaded server using Go programming language. We will explore the basics of networking and concurrency in Go and understand how to handle multiple client connections simultaneously. By the end of this tutorial, you will have a working multithreaded server that can handle concurrent client requests efficiently.

Prerequisites

Before starting this tutorial, you should have a basic understanding of Go programming language and its syntax. Familiarity with networking concepts such as IP addresses, ports, and protocols will be helpful but not mandatory. Make sure you have Go installed on your system.

Setting Up the Project

  1. Open your terminal or command prompt.
  2. Create a new directory for your project: mkdir multithreaded-server

  3. Navigate into the project directory: cd multithreaded-server

  4. Initialize a new Go module: go mod init example.com/server

Creating the Server

  1. Create a new file called main.go in your project directory.

  2. Open main.go in a text editor.

     package main
    
 import (
 	"fmt"
 	"net"
 )
    
 func handleRequest(conn net.Conn) {
 	// Handle client request here
 }
    
 func main() {
 	// Set up server address
 	address := "localhost:8080"
    
 	// Create a TCP listener
 	listener, err := net.Listen("tcp", address)
 	if err != nil {
 		fmt.Println("Error:", err)
 		return
 	}
 	defer listener.Close()
    
 	fmt.Println("Server started on", address)
    
 	// Accept and handle client connections
 	for {
 		conn, err := listener.Accept()
 		if err != nil {
 			fmt.Println("Error:", err)
 		}
    
 		go handleRequest(conn)
 	}
 }

    Let’s understand the code:

    • We import the necessary packages, including fmt for basic I/O and net for networking.
    • The handleRequest function will be responsible for handling each client request. You can write your own logic here.
    • In the main function, we specify the server address to listen on. In this example, we are using localhost and port 8080.
    • We create a TCP listener using net.Listen and handle any errors that occur during the process.
    • We start an infinite loop that accepts new client connections using listener.Accept().
    • For each connection, we spawn a new goroutine and call the handleRequest function using go.

Handling Concurrent Connections

Now that we have our basic server set up, let’s implement the logic for handling concurrent client connections.

package main

import (
	"fmt"
	"net"
)

func handleRequest(conn net.Conn) {
	defer conn.Close()

	// Read client request
	buffer := make([]byte, 1024)
	n, err := conn.Read(buffer)
	if err != nil {
		fmt.Println("Error reading:", err)
		return
	}

	// Process request (you can replace this with your own logic)
	request := string(buffer[:n])
	response := "Hello, " + request

	// Send response to client
	_, err = conn.Write([]byte(response))
	if err != nil {
		fmt.Println("Error writing:", err)
	}
}

// Rest of the code remains the same

In the modified code, we made a few changes:

  • We add conn.Close() at the beginning of the handleRequest function to ensure the connection is closed before the function returns.
  • We read the client request using conn.Read and store it in a buffer.
  • We process the request and generate the response. In this example, we simply append “Hello, “ to the client request.
  • We send the response back to the client using conn.Write.

Testing the Server

To test the server, we can create a simple client program that sends a request and receives the response.

  1. Create a new file called client.go in your project directory.

  2. Open client.go in a text editor.

     package main
    
 import (
 	"fmt"
 	"net"
 )
    
 func main() {
 	// Set up server address
 	address := "localhost:8080"
    
 	conn, err := net.Dial("tcp", address)
 	if err != nil {
 		fmt.Println("Error:", err)
 		return
 	}
 	defer conn.Close()
    
 	request := "John Doe"
    
 	// Send request to server
 	_, err = conn.Write([]byte(request))
 	if err != nil {
 		fmt.Println("Error writing:", err)
 		return
 	}
    
 	// Read response from server
 	buffer := make([]byte, 1024)
 	n, err := conn.Read(buffer)
 	if err != nil {
 		fmt.Println("Error reading:", err)
 		return
 	}
    
 	response := string(buffer[:n])
 	fmt.Println("Response:", response)
 }

    In the client code:

    • We create a TCP connection to the server using net.Dial and handle any errors that occur during the process.
    • We send a request to the server using conn.Write.
    • We read the response from the server using conn.Read and display it.

    To test the server, follow these steps:

  3. Open a terminal or command prompt.
  4. Navigate to your project directory: cd multithreaded-server
  5. Start the server: go run main.go
  6. Open another terminal or command prompt.

  7. Navigate to your project directory: cd multithreaded-server

  8. Start the client: go run client.go

    You should see the response from the server displayed in the client terminal.

Conclusion

In this tutorial, we learned how to create a multithreaded server in Go. We explored basic networking concepts and utilized Go’s concurrency features to handle multiple client connections simultaneously. We covered setting up the project, creating the server, handling concurrent connections, and testing the server using a client program. You can extend this server by implementing your own logic and protocols based on your use case.

I hope this tutorial was helpful in understanding how to build a multithreaded server using Go. Happy coding!

Published:

Related Articles