List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());
Set<Integer> synchronizedSet = Collections.synchronizedSet(new HashSet<>());
Map<Integer, String> synchronizedMap = Collections.synchronizedMap(new HashMap<>());
Эти методы оборачивают оригинальные коллекции в специальные прокси-объекты, которые обеспечивают синхронизацию доступа к ним.

List<String> copyOnWriteList = new CopyOnWriteArrayList<>();
Set<String> copyOnWriteSet = new CopyOnWriteArraySet<>();
Эти коллекции оптимизированы для сценариев, где частое чтение данных значительно превосходит частоту их изменения, так как они избегают блокировок при чтении.

Map<Integer, String> concurrentMap = new ConcurrentHashMap<>();
В отличие от Collections.synchronizedMap(), ConcurrentHashMap предоставляет более гибкие методы для работы с параллельными потоками, такие как putIfAbsent(), replace() и computeIfAbsent().

public static <T> List<T> synchronizedList(List<T> list) {
    return new SynchronizedList<>(list);
}

static class SynchronizedList<E> implements List<E> {
    private final List<E> list;

    public synchronized boolean add(E e) {
        synchronized (this) {
            return list.add(e);
        }
    }

    // Другие методы с аналогичной синхронизацией
}
В данном примере каждый метод обернут в блок synchronized, что гарантирует, что только один поток сможет выполнять операцию над коллекцией в любой момент времени.

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}
Здесь используется ReentrantLock для блокировки доступа при изменении коллекции, а чтение происходит без блокировок, что делает коллекцию чрезвычайно эффективной при большом количестве операций чтения.

static class Segment<K,V> extends ReentrantLock {
    volatile HashEntry<K,V>[] table;
    // Методы для работы с сегментами карты
}
Каждая операция, которая изменяет данные, блокирует только соответствующий сегмент, что значительно увеличивает параллелизм и производительность по сравнению с глобальной блокировкой.

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;

public class RequestHistoryManager {
    private final Map<String, List<String>> clientRequestHistory = Collections.synchronizedMap(new HashMap<>());

    public void addRequest(String clientId, String request) {
        clientRequestHistory.computeIfAbsent(clientId, k -> Collections.synchronizedList(new ArrayList<>())).add(request);
    }

    public List<String> getRequestHistory(String clientId) {
        return clientRequestHistory.getOrDefault(clientId, new ArrayList<>());
    }
}

// Пример использования
RequestHistoryManager manager = new RequestHistoryManager();

manager.addRequest("client1", "GET /index.html");
manager.addRequest("client1", "POST /login");
manager.addRequest("client2", "GET /products");

System.out.println(manager.getRequestHistory("client1"));
System.out.println(manager.getRequestHistory("client2"));
В этом примере clientRequestHistory представляет собой синхронизированную карту, а списки запросов для каждого клиента также являются синхронизированными. Это гарантирует, что добавление и получение истории запросов будет происходить корректно даже при параллельном доступе.

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class TaskQueueManager {
    private final List<String> taskQueue = Collections.synchronizedList(new LinkedList<>());

    public void addTask(String task) {
        taskQueue.add(task);
    }

    public String getNextTask() {
        if (taskQueue.isEmpty()) {
            return null;
        }
        return taskQueue.remove(0);
    }
}

// Пример использования
TaskQueueManager taskQueueManager = new TaskQueueManager();

// Добавление задач
taskQueueManager.addTask("Task 1");
taskQueueManager.addTask("Task 2");
taskQueueManager.addTask("Task 3");

// Потоки обработки задач
Runnable worker = () -> {
    String task;
    while ((task = taskQueueManager.getNextTask()) != null) {
        System.out.println(Thread.currentThread().getName() + " processing " + task);
    }
};

Thread worker1 = new Thread(worker);
Thread worker2 = new Thread(worker);

worker1.start();
worker2.start();
Здесь taskQueue — это синхронизированный список, используемый как очередь задач. Потоки worker1 и worker2 одновременно извлекают задания из этой очереди и обрабатывают их. Благодаря синхронизации, мы гарантируем, что каждое задание будет обработано только одним потоком.

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class VisitCounter {
    private final Map<String, Integer> visitCounts = Collections.synchronizedMap(new HashMap<>());

    public void recordVisit(String page) {
        visitCounts.merge(page, 1, Integer::sum);
    }

    public int getVisitCount(String page) {
        return visitCounts.getOrDefault(page, 0);
    }
}

// Пример использования
VisitCounter visitCounter = new VisitCounter();

// Моделируем посещения страниц
Runnable visitSimulator = () -> {
    for (int i = 0; i < 1000; i++) {
        visitCounter.recordVisit("/index.html");
        visitCounter.recordVisit("/contact.html");
    }
};

Thread thread1 = new Thread(visitSimulator);
Thread thread2 = new Thread(visitSimulator);

thread1.start();
thread2.start();

try {
    thread1.join();
    thread2.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}

System.out.println("Index Page Visits: " + visitCounter.getVisitCount("/index.html"));
System.out.println("Contact Page Visits: " + visitCounter.getVisitCount("/contact.html"));
В этом примере мы используем synchronizedMap для подсчета посещений страниц. Метод merge() безопасен для использования в многопоточной среде, что позволяет корректно увеличивать счетчики.

import java.util.Queue;
import java.util.LinkedList;
import java.util.Collections;

public class SynchronizedTaskQueue {
    private final Queue<String> taskQueue = Collections.synchronizedList(new LinkedList<>());

    public void addTask(String task) {
        synchronized (taskQueue) {
            taskQueue.add(task);
            taskQueue.notify(); // Уведомляем ждущий поток о новой задаче
        }
    }

    public String getTask() throws InterruptedException {
        synchronized (taskQueue) {
            while (taskQueue.isEmpty()) {
                taskQueue.wait(); // Ждем, пока появится новая задача
            }
            return taskQueue.poll();
        }
    }
}

// Пример использования
SynchronizedTaskQueue queue = new SynchronizedTaskQueue();

// Поток для добавления задач
Thread producer = new Thread(() -> {
    for (int i = 0; i < 5; i++) {
        queue.addTask("Task " + i);
    }
});

// Поток для обработки задач
Thread consumer = new Thread(() -> {
    try {
        for (int i = 0; i < 5; i++) {
            String task = queue.getTask();
            System.out.println("Processing " + task);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
});

producer.start();
consumer.start();
В этом примере мы используем синхронизированную очередь задач, где метод addTask() добавляет задачи в очередь и уведомляет ждущие потоки, а метод getTask() ждет появления новой задачи, если очередь пуста. Таким образом, обеспечивается безопасный доступ к общему ресурсу в многопоточной среде.