Loading post...
Back to Articles
Building Real-Time Systems with Go: WebSockets, Goroutines, and Channel Orchestration
•2 minute read
Master the art of building blazingly fast real-time systems using Go's concurrency primitives and learn why goroutines are the secret weapon
SA
Systems Architecture
rayanstudio
Go's concurrency model isn't just elegant—it's a paradigm shift in how we think about real-time systems.
The Goroutine Advantage
A goroutine is not a thread. It's lighter, faster, and managed by the Go runtime. You can spawn millions of them.
func main() {
for i := 0; i < 1_000_000; i++ {
go func(id int) {
// Each goroutine uses only ~2KB
time.Sleep(time.Hour)
}(i)
}
}Memory footprint:
- OS Thread: ~2MB stack
- Goroutine: ~2KB stack (grows dynamically)
Channel-Based Architecture
Channels are Go's secret sauce for coordination:
type Message struct {
UserID string
Content string
Timestamp time.Time
}
type Hub struct {
clients map[*Client]bool
broadcast chan Message
register chan *Client
unregister chan *Client
}
func (h *Hub) Run() {
for {
select {
case client := <-h.register:
h.clients[client] = true
case client := <-h.unregister:
if _, ok := h.clients[client]; ok {
delete(h.clients, client)
close(client.send)
}
case message := <-h.broadcast:
for client := range h.clients {
select {
case client.send <- message:
default:
close(client.send)
delete(h.clients, client)
}
}
}
}
}WebSocket Implementation
Here's a production-ready WebSocket server:
func (c *Client) writePump() {
ticker := time.NewTicker(pingPeriod)
defer func() {
ticker.Stop()
c.conn.Close()
}()
for {
select {
case message, ok := <-c.send:
c.conn.SetWriteDeadline(time.Now().Add(writeWait))
if !ok {
c.conn.WriteMessage(websocket.CloseMessage, []byte{})
return
}
w, err := c.conn.NextWriter(websocket.TextMessage)
if err != nil {
return
}
w.Write(message)
// Batch additional messages
n := len(c.send)
for i := 0; i < n; i++ {
w.Write(newline)
w.Write(<-c.send)
}
if err := w.Close(); err != nil {
return
}
case <-ticker.C:
c.conn.SetWriteDeadline(time.Now().Add(writeWait))
if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
return
}
}
}
}Performance Characteristics
On a modest server:
- 10,000 concurrent WebSocket connections: ~150MB RAM
- Message throughput: 100,000+ msgs/sec
- Latency: < 1ms for local delivery
The Beauty of Select
The select statement is Go's multiplexer:
select {
case msg := <-ch1:
// Handle channel 1
case msg := <-ch2:
// Handle channel 2
case <-time.After(timeout):
// Timeout case
default:
// Non-blocking option
}This single construct replaces complex event loops in other languages.