Atomic vs Mutex, Blocking vs Non‑Blocking, Read/Write Splitting (RWMutex), Logging | Concurrency Patterns и Best Practices часть 5 | Go ↔ Java

В этой статье мы разберём ключевые подходы к работе с параллелизмом и синхронизацией в Go и Java. Мы сравним, как одни и те же задачи решаются на этих языках, покажем идиомы, паттерны и лучшие практики. Материал будет полезен как Java-разработчикам, изучающим Go, так и гоферам, которые хотят понять привычные подходы Java.

Atomic vs Mutex

Синхронизация доступа к данным может быть реализована с помощью атомарных операций или мьютексов. Атомарные операции легче и быстрее, но ограничены простыми типами. Мьютексы универсальнее, но добавляют накладные расходы.

Go: Atomic

// Пример атомарного инкремента
import (
    "fmt"
    "sync/atomic"
)

func main() {
    var counter int32 = 0
    atomic.AddInt32(&counter, 1) // атомарное увеличение на 1
    fmt.Println(counter) // вывод: 1
}
// Комментарий: atomic.AddInt32 гарантирует, что операция инкремента выполнится без гонок.

Java: Atomic

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    public static void main(String[] args) {
        AtomicInteger counter = new AtomicInteger(0);
        counter.incrementAndGet(); // атомарное увеличение на 1
        System.out.println(counter.get()); // вывод: 1
    }
}
// Комментарий: AtomicInteger обеспечивает атомарные операции без блокировки.

Go: Mutex

import (
    "fmt"
    "sync"
)

func main() {
    var counter int
    var mu sync.Mutex

    mu.Lock()         // блокируем доступ
    counter++         // безопасная операция
    mu.Unlock()       // разблокируем
    fmt.Println(counter) // вывод: 1
}
// Комментарий: Мьютекс гарантирует эксклюзивный доступ к ресурсу.

Java: Mutex (synchronized)

public class MutexExample {
    private int counter = 0;

    public synchronized void increment() { // synchronized = мьютекс
        counter++;
    }

    public static void main(String[] args) {
        MutexExample ex = new MutexExample();
        ex.increment();
        System.out.println(ex.counter); // вывод: 1
    }
}
// Комментарий: synchronized блокирует объект на время выполнения метода.

Атомарные операции лучше использовать для простых счетчиков и флагов. Мьютексы нужны для сложных структур данных или последовательных операций.

В бизнесе atomic удобно применять для счетчиков посещений страниц, лайков, транзакционных лимитов. Мьютексы полезны для работы с кэшами, очередями задач или транзакциями, где нужно обеспечить целостность сложной структуры.

Blocking vs Non‑Blocking

Blocking операции останавливают поток до завершения задачи. Non-blocking позволяют продолжать выполнение других задач. В Go это часто каналы и select, в Java — Future, CompletableFuture и NIO.

Go: Blocking Channel

ch := make(chan int)

go func() {
    ch <- 42 // блокируется, пока кто-то не прочитает
}()

val := <-ch
fmt.Println(val) // вывод: 42
// Комментарий: канал по умолчанию синхронный, операция записи блокирует горутину.

Java: BlockingQueue

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(1);

        new Thread(() -> {
            try {
                queue.put(42); // блокируется, пока не будет места
            } catch (InterruptedException e) { }
        }).start();

        Integer val = queue.take(); // блокируется, пока не появится элемент
        System.out.println(val); // вывод: 42
    }
}
// Комментарий: BlockingQueue упрощает синхронизацию между потоками.

Go: Non-Blocking

select {
case ch <- 42: // если можно отправить
    fmt.Println("Отправлено")
default:
    fmt.Println("Канал занят, продолжаем")
}
// Комментарий: select с default позволяет не блокировать горутину.

Java: Non-Blocking (CompletableFuture)

import java.util.concurrent.CompletableFuture;

public class NonBlockingExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 42);

        future.thenAccept(val -> System.out.println("Результат: " + val));

        System.out.println("Продолжаем выполнение");
// Комментарий: CompletableFuture не блокирует поток, результат обрабатывается асинхронно.
    }
}

Blocking удобно для простых очередей задач и синхронизации в узких местах. Non-blocking критично для веб-сервисов, потоковой обработки и высоконагруженных систем, чтобы не держать потоки в ожидании.

Read/Write Splitting (RWMutex)

Если данные читаются чаще, чем пишутся, используют Read/Write блокировки. Go — sync.RWMutex, Java — ReentrantReadWriteLock.

Go: RWMutex

import "sync"

var mu sync.RWMutex
var data int

// Чтение
mu.RLock()
fmt.Println(data)
mu.RUnlock()

// Запись
mu.Lock()
data = 100
mu.Unlock()
// Комментарий: RLock позволяет нескольким горутинам читать одновременно.

Java: ReentrantReadWriteLock

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class RWExample {
    private final ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
    private int data;

    public void read() {
        rw.readLock().lock();
        try {
            System.out.println(data);
        } finally {
            rw.readLock().unlock();
        }
    }

    public void write(int val) {
        rw.writeLock().lock();
        try {
            data = val;
        } finally {
            rw.writeLock().unlock();
        }
    }
}
// Комментарий: readLock позволяет множественные чтения, writeLock эксклюзивное изменение.

RWLock полезен для кэшей, конфигураций и shared-ресурсов, где чтение преобладает над записью. Плюсы: высокая параллельность чтения. Минусы: сложнее управление, возможны deadlock при неправильном использовании.

Logging Best Practices

Логирование помогает понимать поведение приложения. В Go популярны log, zap, zerolog; в Java — SLF4J, Log4j, Logback. Основной принцип — структурированные и асинхронные логи.

Go: Structured Logging

import (
    "go.uber.org/zap"
)

func main() {
    logger, _ := zap.NewProduction()
    defer logger.Sync()
    logger.Info("User logged in", zap.String("user", "Alice"), zap.Int("id", 42))
}
// Комментарий: Структурированные логи позволяют легко фильтровать и анализировать события.

Java: Structured Logging (SLF4J + Logback)

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LoggingExample {
    private static final Logger logger = LoggerFactory.getLogger(LoggingExample.class);

    public static void main(String[] args) {
        logger.info("User logged in: user={}, id={}", "Alice", 42);
    }
}
// Комментарий: SLF4J поддерживает параметры, что уменьшает накладные расходы на форматирование.

Используйте логирование для аудита, мониторинга и отладки. Асинхронные и структурированные логи повышают производительность и читаемость.

Вывод / Итог

Сравнивая Go и Java, видно, что многие концепции совпадают, но реализация и идиомы отличаются. Go делает упор на легковесные горутины и каналы, атомарные операции и RWMutex, а Java — на традиционные потоки, synchronized, ReentrantLocks и CompletableFuture для асинхронности. Для практики:

• Используйте атомарные операции для простых счетчиков и флагов.
• Мьютексы и RWLocks — для комплексных структур с частым чтением.
• Blocking подходит для очередей задач, Non-blocking — для веб и high-load систем.
• Логируйте структурировано и асинхронно для мониторинга и отладки.

Понимание этих паттернов и идиом позволит легко переносить навыки между Go и Java, использовать преимущества каждого языка и избегать типичных ошибок при работе с параллельностью и синхронизацией.