Пакет sync: мьютексы, пулы и одноразовая инициализация
Пакет sync: мьютексы, пулы и одноразовая инициализация
Каналы - не единственный способ синхронизации. Пакет
sync даёт низкоуровневые примитивы.
Слово «атомарно» здесь означает не то же, что в транзакциях базы: операция неделима относительно других наблюдателей, никто не увидит половину - и никакого отката при этом не существует. Разбор всех трёх смыслов термина - в уроке про транзакции.
sync.Mutex
type SafeCounter struct {
mu sync.Mutex
v map[string]int
}
// NewSafeCounter - обязательный конструктор, а не удобство.
//
// Нулевое значение SafeCounter непригодно: map после `var c SafeCounter`
// равна nil, и первый же Inc даёт panic «assignment to entry in nil map».
// Мьютекс при этом рабочий, поэтому падение выглядит как проблема
// конкурентности, хотя причина в незаполненной карте.
//
// Правило общее: если нулевое значение типа непригодно, у типа должен быть
// конструктор - иначе `var x T` компилируется и падает в рантайме.
func NewSafeCounter() *SafeCounter {
return &SafeCounter{v: make(map[string]int)}
}
func (c *SafeCounter) Inc(key string) {
c.mu.Lock()
defer c.mu.Unlock()
c.v[key]++
}
func (c *SafeCounter) Value(key string) int {
c.mu.Lock()
defer c.mu.Unlock()
return c.v[key]
}
<?php
declare(strict_types=1);
namespace App\Concurrency;
use Symfony\Component\Lock\LockFactory;
final readonly class SafeCounter
{
public function __construct(
private LockFactory $lockFactory,
private CounterStorageInterface $storage,
) {}
public function inc(string $key): void
{
$lock = $this->lockFactory->createLock(\sprintf('counter:%s', $key));
$lock->acquire(true); // блокирующий
try {
$this->storage->increment($key);
} finally {
$lock->release();
}
}
}
В PHP-FPM in-process mutex не нужен: каждый request - отдельный процесс, shared memory между запросами нет. Реальная задача - синхронизация между процессами/воркерами/серверами. Промышленный референс -
symfony/lockс file/Redis/Postgres backend (distributed lock). Скорость - миллисекунды, а не наносекунды, как уsync.Mutex.
Конфигурация Redis-lock:
framework:
lock:
counter: '%env(REDIS_URL)%' # redis://redis:6379
Альтернатива - БД-уровень через Postgres advisory lock или SELECT ... FOR UPDATE в транзакции.
defer c.mu.Unlock() ставят сразу после Lock(): отложенный вызов выполнится при любом выходе из функции - обычном return, раннем return по ошибке и даже при panic. Без defer легко забыть Unlock на одном из путей, и следующий Lock этого мьютекса повиснет навсегда.
sync.RWMutex
Когда чтений много, а записей мало, RWMutex обычно быстрее: читатели проходят одновременно, писатель получает эксклюзив.
ℹ️ «Обычно», а не «всегда»
RWMutex сложнее обычного мьютекса, и на коротких критических секциях эта сложность съедает выигрыш:
RLock/RUnlockделают больше атомарных операций, чемLock/Unlock, а на многих ядрах ещё и дёргают одну общую кеш-линию. На чтении из map по ключу разница может быть не в пользу RWMutex.Плюс два ограничения, о которых узнают на отладке:
- он не рекурсивный. Взял
RLockи внутри вызвал функцию, которая берётRLockещё раз, - в норме это работает, но если между ними встанет ожидающий писатель, получишь дедлок: новые читатели блокируются, чтобы писатель не голодал;RLockне превращается вLock. Апгрейда нет: нужно отпустить чтение, взять запись и перепроверить условие - за это время состояние могло измениться.Что делать: брать
sync.Mutexпо умолчанию, а RWMutex - когда замер на своей нагрузке показал выигрыш.go test -benchс-cpu=1,4,8покажет разницу быстрее любых рассуждений.
type Cache struct {
mu sync.RWMutex
data map[string]string
}
// NewCache - конструктор обязателен: у нулевого Cache map равна nil,
// и первый Set упадёт с «assignment to entry in nil map».
func NewCache() *Cache {
return &Cache{data: make(map[string]string)}
}
func (c *Cache) Get(key string) (string, bool) {
c.mu.RLock()
defer c.mu.RUnlock()
val, ok := c.data[key]
return val, ok
}
func (c *Cache) Set(key, value string) {
c.mu.Lock()
defer c.mu.Unlock()
c.data[key] = value
}
<?php
declare(strict_types=1);
namespace App\Concurrency;
use Symfony\Component\Cache\Adapter\RedisAdapter;
use Symfony\Component\Lock\LockFactory;
use Symfony\Contracts\Cache\ItemInterface;
final readonly class DistributedCache
{
public function __construct(
private RedisAdapter $cache,
private LockFactory $lockFactory,
) {}
public function get(string $key): ?string
{
return $this->cache->get($key, static fn (ItemInterface $item): ?string => null);
}
public function set(string $key, string $value): void
{
$lock = $this->lockFactory->createLock(\sprintf('cache:%s', $key));
$lock->acquire(true);
try {
$item = $this->cache->getItem($key);
$item->set($value);
$this->cache->save($item);
} finally {
$lock->release();
}
}
}
symfony/lockне различает read/write локи - это всегда эксклюзивная блокировка. В монопроцессном PHP-FPM RWMutex и не нужен: shared memory нет. Если задача в распределённой системе и read-heavy - используют cache layer (symfony/cacheс Redis), писатели идут через lock, читатели читают из кеша без блокировки.
sync.Once
Гарантирует, что функция вызовется ровно один раз.
var (
instance *Database
once sync.Once
)
func GetDB() *Database {
once.Do(func() {
instance = connectToDatabase()
})
return instance
}
<?php
declare(strict_types=1);
namespace App\Concurrency;
use Doctrine\DBAL\Connection;
// сервис shared по умолчанию - инициализируется один раз на процесс
final readonly class DatabaseProvider
{
public function __construct(private Connection $connection) {}
public function get(): Connection
{
return $this->connection;
}
}
В PHP-FPM «однократная инициализация» автоматическая на уровне DI-контейнера: Symfony создаёт singleton-сервис один раз в lifecycle процесса. Эквивалент
sync.Once- service definition с дефолтнымshared: true(по умолчанию). Между запросами FPM состояние не разделяет, кеш bootcache решает холодный старт.
Для lazy-init внутри одного request - private property + ??=:
<?php
declare(strict_types=1);
namespace App\Concurrency;
use PDO;
final class LazyResource
{
private ?PDO $pdo = null;
public function __construct(private readonly string $dsn) {}
public function pdo(): PDO
{
return $this->pdo ??= new PDO($this->dsn);
}
}
С Go 1.21 есть короткие обёртки над Once: sync.OnceFunc(f) возвращает функцию, которая вызовет f один раз, а sync.OnceValue(f) ещё и запомнит результат. Пример выше сворачивается в одну строку var getDB = sync.OnceValue(connectToDatabase): первый вызов getDB() подключается, остальные возвращают тот же *Database.
sync.WaitGroup
Ждёт, пока завершится группа горутин. Три правила:
wg.Add(n)вызывай доgo, в основной горутине. ЕслиAddвнутри горутины,Waitможет вернуться раньше, чем горутина успеет его вызвать;defer wg.Done()первой строкой горутины - тогда счётчик уменьшится при любом выходе, даже при panic;WaitGroupнельзя копировать после первого использования: передавай*sync.WaitGroup. Копию с нулевым счётчиком поймаетgo vet(проверкаcopylocks).
⚠️ Не копируй ничего из sync
Правило про копирование общее для
Mutex,RWMutex,WaitGroup,OnceиCond: каждый хранит состояние в своих полях, и копия живёт отдельной жизнью. Копия мьютекса блокируется независимо от оригинала, и защита пропадает. КопияWaitGroupначинает с нулевым счётчиком, и еёWaitвернётся сразу. КопияOnceне знает, что функция уже выполнялась, и вызовет её ещё раз. Поэтому структуры с такими полями передают по указателю и не возвращают по значению;go vet(copylocks) ловит большинство таких копий.
var wg sync.WaitGroup
for _, url := range urls {
wg.Add(1) // до go
go func() {
defer wg.Done()
fetch(url)
}()
}
wg.Wait()
<?php
declare(strict_types=1);
use React\Http\Browser;
use function React\Promise\all;
// Аналог WaitGroup в ReactPHP - all(): ждёт, пока завершатся все промисы группы.
$browser = new Browser();
$promises = [];
foreach ($urls as $url) {
$promises[] = $browser->get($url);
}
all($promises)->then(static function (array $responses): void {
echo \count($responses) . " done\n";
});
С Go 1.25 то же самое короче: wg.Go(func() { fetch(url) }) сам делает Add(1) и Done().
sync.Map
Оптимизированный для конкурентного доступа map (как устроен изнутри). Полезен когда ключи стабильны или при disjoint access.
var cache sync.Map
cache.Store("key", "value")
val, ok := cache.Load("key")
if ok {
fmt.Println(val.(string))
}
cache.Range(func(key, value any) bool {
fmt.Printf("%v: %v\n", key, value)
return true // false чтобы остановить
})
⚠️ Когда НЕ использовать sync.Map
Для большинства случаев обычный
map+sync.RWMutexпроще и типобезопаснее:sync.Mapхранитany, и ошибки типов всплывут только в рантайме.sync.Mapхорош для кешей с read-heavy нагрузкой и для случаев, когда разные горутины работают с разными ключами. С Go 1.24 он устроен как concurrent hash-trie, и запись в нём стала заметно быстрее, поэтому выбор между ним иmap+RWMutexподтверждай бенчмарком на своей нагрузке.
sync.Pool
Повторное использование объектов для снижения нагрузки на GC.
⚠️ Pool - это кеш без гарантий, а не хранилище
sync.Poolне обещает сохранить положенное. Сборщик мусора очищает пул: объект, который никто не взял за два цикла GC, пропадает. Поэтому:
Getможет вернуть свежий объект отNew- в том числе сразу послеPut. Считать, что объект «наш» и что-то в нём сохранилось, нельзя;- если
Newне задан,Getвернётnil- это самый частый паникующий сценарий с пулами;- объект надо очищать перед возвратом (
buf.Reset()в примере ниже), иначе следующий владелец получит чужие данные. Для буферов это утечка данных между запросами, а не просто беспорядок;- не кладите в пул то, чей размер непредсказуем. Разросшийся до мегабайт буфер будет жить в пуле и держать память; в стандартной библиотеке из-за этого проверяют
capпередPut.И главное: пул имеет смысл, когда профилирование показало давление на аллокатор. Добавленный «на всякий случай» он усложняет код и не меняет ничего, а иногда делает хуже - объекты живут дольше и увеличивают живую кучу: GC срабатывает реже, но каждый раз обходит больше памяти.
var bufferPool = sync.Pool{
New: func() any {
return new(bytes.Buffer)
},
}
func processRequest() {
buf := bufferPool.Get().(*bytes.Buffer)
defer func() {
buf.Reset()
bufferPool.Put(buf)
}()
buf.WriteString("processing...")
// используем buf
}
<?php
declare(strict_types=1);
namespace App\Concurrency;
use PDO;
final class ConnectionPool
{
/** @var list<PDO> */
private array $available = [];
public function __construct(
private readonly string $dsn,
private readonly int $maxSize = 10,
) {}
public function acquire(): PDO
{
return \array_pop($this->available) ?? new PDO($this->dsn);
}
public function release(PDO $pdo): void
{
if (\count($this->available) < $this->maxSize) {
$this->available[] = $pdo;
}
}
}
Прямого аналога
sync.Poolв PHP нет: между запросами FPM зачистит память, внутри одного request объект-аллокации редко становятся узким местом. Если и нужен «пул объектов», то для тяжёлых ресурсов (DB-соединения, gRPC клиенты) - это решается на уровне DI-контейнера (singleton-сервисы) или connection pooling в Doctrine. Для длинноживущих воркеров (Swoole / ReactPHP / Symfony Messenger) можно делать пул вручную через массив.
sync.Cond (редко нужен)
Cond - способ для горутин ждать, пока станет верным некоторое условие над общими данными. Ждущая вызывает Wait(), та, что изменила данные, будит одну ждущую через Signal() или всех через Broadcast(). В большинстве задач то же самое проще сделать каналом.
var (
mu sync.Mutex
cond = sync.NewCond(&mu)
ready bool
)
// Ожидающая горутина
go func() {
mu.Lock()
for !ready {
cond.Wait() // атомарно: Unlock → sleep → Lock
}
fmt.Println("ready!")
mu.Unlock()
}()
// Сигнализирующая горутина
mu.Lock()
ready = true
cond.Signal() // или cond.Broadcast() для всех
mu.Unlock()