Go concurrency slice of pointers of structs with mutexes

package main

import (
    "fmt"
    "sync"
)

type Resource struct {
    data int
}

func (r *Resource) increment() {
    r.data++
}

type Client struct {
    id       int
    resource Resource
    mu       sync.RWMutex
}

type ActiveClients struct {
    clients []*Client
    mu      sync.RWMutex
}

func (ac *ActiveClients) add(client *Client) {
    ac.mu.Lock()
    defer ac.mu.Unlock()
    if ac.clients == nil {
        ac.clients = make([]*Client, 0)
    }
    ac.clients = append(ac.clients, client)
}

func (ac *ActiveClients) incrementResource(clientId int) {
    ac.mu.RLock()
    defer ac.mu.RUnlock()
    for _, existingClient := range ac.clients {
        if existingClient.id == clientId {
            existingClient.mu.Lock()
            defer existingClient.mu.Unlock()
            existingClient.resource.increment()
            return
        }
    }
}

type anError struct {
    errorMsg string
}

func (m anError) Error() string {
    return m.errorMsg
}

func (ac *ActiveClients) getResource(clientId int) (Resource, error) {
    ac.mu.RLock()
    defer ac.mu.RUnlock()

    for _, existingClient := range ac.clients {
        if existingClient.id == clientId {
            existingClient.mu.RLock()
            defer existingClient.mu.RUnlock()
            return existingClient.resource, nil
        }
    }
    return Resource{}, anError{"could not find resource"}
}

var wg sync.WaitGroup

func main() {
    var users ActiveClients
    users.add(&Client{id: 3})

    wg.Add(10)
    for i := 0; i < 10; i++ {
        go func() {
            users.incrementResource(3)
            wg.Done()
        }()
    }
    wg.Wait()

    res, err := users.getResource(3)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("resource data = %v\n", res.data)
    }
}