Race condition while trying to update a map

Introduction

I am trying to build a client-server application in /go.

There is only one instance for the server which contains list of tasks, which are nothing but string data. The server maintains a map of task and it's allocation status.

On the other hand the client can have multiple instances, and requests the server for the tasks. When a task is allocated the server updates allocation status to true.

The communication between the client and server is over go rpc.

Please refer to this for better understanding.

To mimic multiple clients, I am spinning up multiple go routines in a single application that make request to the server.

Code

Server

package main
import (
"fmt"
"log"
"net/http"
"net/rpc"
"sync"
)
type Container struct {
mu   sync.Mutex
list map[string]bool
}
var ListOfTasks Container
func (c *Container) UpdateList() string {
var t string
ListOfTasks.mu.Lock()
defer ListOfTasks.mu.Unlock()
for k, v := range c.list {
if !v {
c.list[k] = true
fmt.Println("Task Name", k)
return k
}
}
return t
}
// RPC Code
type RPCServer struct{}
type Input struct {}
type Output struct {
Message string
}
func (s *RPCServer) GetTask(i *Input, o *Output) error {
o.Message = ListOfTasks.UpdateList()
return nil
}
//
func init() {
ListOfTasks = Container{}
ListOfTasks.list = map[string]bool{
"task1" : false,
"task2" : false,
"task3" : false,
}
}
func main() {
some := new(RPCServer)
rpc.Register(some)
rpc.HandleHTTP()
fmt.Println("Listening on port 1234")
err := http.ListenAndServe(":1234", nil)
if err != nil {
log.Fatal("bruh", err.Error())
}
}

Client

package main
import (
"fmt"
"log"
"net/rpc"
"sync"
)
type Input struct {
Name string
}
type Output struct {
Message string	
}
func main() {
client, err := rpc.DialHTTP("tcp", "localhost:1234")
if err != nil {
log.Fatal("bruh!", err.Error())
}
arg := &Input{}	
reply := Output{}
var wg sync.WaitGroup
wg.Add(4)
for i := 0; i< 4; i++ {
go func(gori int) {
defer wg.Done()
err = client.Call("RPCServer.GetTask", arg, &reply)
if err != nil {
log.Fatal("bruh!", err.Error())
}
fmt.Printf("#%d: message: %s\n", gori, reply.Message)
}(i)	
}
wg.Wait()
}

The Problem

When multiple clients make request to the server asking for a task, we run into a race condition, which is not detected by the golang's race detector. It can be observed in the application's output.

Server's output

Listening on port 1234
Task Name task1
Task Name task2
Task Name task3

Client's output

#1: message: task3
#2: message: task3
#0: message: task3
#3: message: task3

The server allocates different tasks to each worker but on the worker's end, everyone receives the same task.

I have lock over the entire for loop where we are searching for an unallocated task.

Other things that I have tried (but didn't work)

1. Using sync.Map: Still ended up with a race condition, which was detected by the golang race detector.

2. Applying lock only on c.list[k] = true: Which caused the same issue that I am facing now.

I have my suspicion on the way I am applying the lock, but I don't understand what I am doing wrong.

I know the problem is caused since there are multiple go routines trying to read from and update the map. And therefore I am applying the lock on the entire section where the reading and writing happens.

Most of the articles or StackOverflow posts that I read had both the server and client in the same application and avoided this problem by using channels. I am not sure how do I use channels in my use case.

Also, eventually this will become a map-reduce application, so I would have to store much more data other than a flag representing the allocation status.

Any help is appreciated, Thanks!

The server is correct (although the code is a little muddled -- why use the mutex on the global ListOfTasks when you have a pointer receiver to your Collection?).

But the client code it wrong: you are using the same &reply pointer in all of your goroutines in the client, meaning that when one client goroutine receives a reply, all the goroutines see it, and then there's a race between receiving the reply and writing it. You need to move the reply := Output{} into the goroutine.

I believe the race detector will detect this, but you have to run it on the client, not on the server.