Locks, channels, and a broker are three ways to coordinate state. An actor is one.

package main

import (
    "context"
    "os"
    "os/signal"
    "syscall"
    "time"

    goakt "github.com/tochemey/goakt/v4/actor"
    "github.com/tochemey/goakt/v4/log"
)

// Greet asks the actor to greet someone; Greeting is its reply.
type Greet struct{ Name string }

type Greeting struct{ Message string }

// Greeter is the actor. State lives in unexported fields; no locks are
// needed because an actor processes one message at a time.
type Greeter struct {
    greeted int
}

var _ goakt.Actor = (*Greeter)(nil)

func (x *Greeter) PreStart(*goakt.Context) error { return nil }

func (x *Greeter) Receive(ctx *goakt.ReceiveContext) {
    switch msg := ctx.Message().(type) {
    case *Greet:
        x.greeted++
        ctx.Response(&Greeting{Message: "Hello, " + msg.Name + "!"})
    default:
        ctx.Unhandled()
    }
}

func (x *Greeter) PostStop(*goakt.Context) error { return nil }

func main() {
    ctx := context.Background()
    logger := log.DefaultLogger

    system, err := goakt.NewActorSystem("quickstart", goakt.WithLogger(logger))
    if err != nil {
        logger.Fatal(err)
    }

    if err := system.Start(ctx); err != nil {
        logger.Fatal(err)
    }

    pid, err := system.Spawn(ctx, "greeter", &Greeter{})
    if err != nil {
        logger.Fatal(err)
    }

    response, err := goakt.Ask(ctx, pid, &Greet{Name: "World"}, time.Second)
    if err != nil {
        logger.Fatal(err)
    }

    logger.Info(response.(*Greeting).Message)

    sig := make(chan os.Signal, 1)
    signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
    <-sig

    _ = system.Stop(ctx)
}