Справочник по синхронизаторам java.util.concurrent.*

import java.util.concurrent.Semaphore;

public class Parking {
    //Парковочное место занято - true, свободно - false
    private static final boolean[] PARKING_PLACES = new boolean[5];
    //Устанавливаем флаг "справедливый", в таком случае метод
    //aсquire() будет раздавать разрешения в порядке очереди
    private static final Semaphore SEMAPHORE = new Semaphore(5, true);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 7; i++) {
            new Thread(new Car(i)).start();
            Thread.sleep(400);
        }
    }

    public static class Car implements Runnable {
        private int carNumber;

        public Car(int carNumber) {
            this.carNumber = carNumber;
        }

        @Override
        public void run() {
            System.out.printf("Автомобиль №%d подъехал к парковке.n", carNumber);
            try {
                //acquire() запрашивает доступ к следующему за вызовом этого метода блоку кода,
                //если доступ не разрешен, нить вызвавшая этот метод блокируется до тех пор,
                //пока семафор не разрешит доступ
                SEMAPHORE.acquire();

                //Ищем свободное место и паркуемся
                for (int i = 0; i < 5; i++)
                    if (!PARKING_PLACES[i]) {     //Если место свободно
                        PARKING_PLACES[i] = true;  //занимаем его
                        System.out.printf("Автомобиль №%d припарковался на месте %d.n", carNumber, i);
                        Thread.sleep(5000);       //Уходим за покупками, к примеру
                        PARKING_PLACES[i] = false;//Освобождаем место
                        break;
                    }

                //release(), напротив, освобождает ресурс
                SEMAPHORE.release();
                System.out.printf("Автомобиль №%d покинул парковку.n", carNumber);
            } catch (InterruptedException e) {
            }
        }
    }
}

Семафор отлично подходит для решения такой задачи: он не дает автомобилю (нити) припарковаться (зайти в заданный блок кода и воспользоваться общим ресурсом) если мест на парковке нет (счётчик равен 0) Стоит отметить, что класс Semaphore поддерживает захват и освобождение более чем одного разрешения за раз, но в данном задаче это не нужно.

1. Каждый из пяти автомобилей подъехал к стартовой прямой;
2. Была дана команда «На старт!»;
3. Была дана команда «Внимание!»;
4. Была дана команда «Марш!».

Важно, чтобы все автомобили стартовали одновременно.

import java.util.concurrent.CountDownLatch;

public class Race {
    //Создаем CountDownLatch на 8 "условий"
    private static final CountDownLatch START = new CountDownLatch(8);
    //Условная длина гоночной трассы
    private static final int trackLength = 500000;

    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 5; i++) {
            new Thread(new Car(i, (int) (Math.random() * 100 + 50))).start();
            Thread.sleep(1000);
        }

        Thread.sleep(1000);
        System.out.println("На старт!");
        START.countDown();//Команда дана, уменьшаем счетчик на 1
        Thread.sleep(1000);
        System.out.println("Внимание!");
        START.countDown();//Команда дана, уменьшаем счетчик на 1
        Thread.sleep(1000);
        System.out.println("Марш!");
        START.countDown();//Команда дана, уменьшаем счетчик на 1
        //счетчик становится равным нулю, и все ожидающие нити
        //одновременно разблокируются
    }

    public static class Car implements Runnable {
        private int carNumber;
        private int carSpeed;//считаем, что скорость автомобиля постоянная

        public Car(int carNumber, int carSpeed) {
            this.carNumber = carNumber;
            this.carSpeed = carSpeed;
        }

        @Override
        public void run() {
            try {
                System.out.printf("Автомобиль №%d подъехал к стартовой прямой.n", carNumber);
                //Автомобиль подъехал к стартовой прямой - условие выполнено
                //уменьшаем счетчик на 1
                START.countDown();
                //метод await() блокирует нить, вызвавшую его, до тех пор, пока
                //счетчик CountDownLatch не станет равен 0
                START.await();
                Thread.sleep(trackLength / carSpeed);//ждем пока проедет трассу
                System.out.printf("Автомобиль №%d финишировал!n", carNumber);
            } catch (InterruptedException e) {
            }
        }
    }
}

CountDownLatch может быть использован в самых разных схемах синхронизации: к примеру, чтобы пока одна нить выполняет работу, заставить другие нити ждать или, наоборот, чтобы заставить нить ждать других, чтобы выполнить работу.

import java.util.concurrent.CyclicBarrier;

public class Ferry {
    private static final CyclicBarrier BARRIER = new CyclicBarrier(3, new FerryBoat());
    //Инициализируем барьер на три нити и таском, который будет выполняться, когда
    //у барьера соберется три нити. После этого, они будут освобождены.

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 9; i++) {
            new Thread(new Car(i)).start();
            Thread.sleep(400);
        }
    }

    //Таск, который будет выполняться при достижении сторонами барьера
    public static class FerryBoat implements Runnable {
        @Override
        public void run() {
            try {
                Thread.sleep(500);
                System.out.println("Паром переправил автомобили!");
            } catch (InterruptedException e) {
            }
        }
    }

    //Стороны, которые будут достигать барьера
    public static class Car implements Runnable {
        private int carNumber;

        public Car(int carNumber) {
            this.carNumber = carNumber;
        }

        @Override
        public void run() {
            try {
                System.out.printf("Автомобиль №%d подъехал к паромной переправе.n", carNumber);
                //Для указания нити о том что она достигла барьера, нужно вызвать метот await()
                //После этого данная нить блокируется, и ждет пока остальные стороны достигнут барьера
                BARRIER.await();
                System.out.printf("Автомобиль №%d продолжил движение.n", carNumber);
            } catch (Exception e) {
            }
        }
    }
}

Когда три нити достигают метода await(), барьерное действие запускается, и паром переправляет три автомобиля из скопившихся. После этого начинается новый цикл.

import java.util.concurrent.Exchanger;

public class Delivery {
    //Создаем обменник, который будет обмениваться типом String
    private static final Exchanger<String> EXCHANGER = new Exchanger<>();

    public static void main(String[] args) throws InterruptedException {
        String[] p1 = new String[]{"{посылка A->D}", "{посылка A->C}"};//Формируем груз для 1-го грузовика
        String[] p2 = new String[]{"{посылка B->C}", "{посылка B->D}"};//Формируем груз для 2-го грузовика
        new Thread(new Truck(1, "A", "D", p1)).start();//Отправляем 1-й грузовик из А в D
        Thread.sleep(100);
        new Thread(new Truck(2, "B", "C", p2)).start();//Отправляем 2-й грузовик из В в С
    }

    public static class Truck implements Runnable {
        private int number;
        private String dep;
        private String dest;
        private String[] parcels;

        public Truck(int number, String departure, String destination, String[] parcels) {
            this.number = number;
            this.dep = departure;
            this.dest = destination;
            this.parcels = parcels;
        }

        @Override
        public void run() {
            try {
                System.out.printf("В грузовик №%d погрузили: %s и %s.n", number, parcels[0], parcels[1]);
                System.out.printf("Грузовик №%d выехал из пункта %s в пункт %s.n", number, dep, dest);
                Thread.sleep(1000 + (long) Math.random() * 5000);
                System.out.printf("Грузовик №%d приехал в пункт Е.n", number);
                parcels[1] = EXCHANGER.exchange(parcels[1]);//При вызове exchange() нить блокируется и ждет
                //пока другая нить вызовет exchange(), после этого произойдет обмен посылками
                System.out.printf("В грузовик №%d переместили посылку для пункта %s.n", number, dest);
                Thread.sleep(1000 + (long) Math.random() * 5000);
                System.out.printf("Грузовик №%d приехал в %s и доставил: %s и %s.n", number, dest, parcels[0], parcels[1]);
            } catch (InterruptedException e) {
            }
        }
    }
}

Как мы видим, когда один грузовик (одна нить) приезжает в пункт Е (достигает точки синхронизации), он ждет пока другой грузовик (другая нить) приедет в пункт Е (достигнет точки синхронизации). После этого происходит обмен посылками (String) и оба грузовика (нити) продолжают свой путь (работу).

import java.util.concurrent.Phaser;

public class Bus {
    private static final Phaser PHASER = new Phaser(1);//Сразу регистрируем главную нить
    //Фазы 0 и 6 - это автобусный парк, 1 - 5 остановки

    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i < 5; i++) {           //Генерируем пассажиров на остановках
            if ((int) (Math.random() * 3) > 0)
                new Passenger(PHASER, i, i + 1);//Этот пассажир выходит на следующей

            if ((int) (Math.random() * 3) == 2)
                new Passenger(PHASER, i, 5);    //Этот пассажир выходит на конечной
        }

        System.out.println("Автобус выехал из парка.");
        PHASER.arrive();//В фазе 0 всего 1 участник

        for (int i = 1; i < 6; i++) {
            System.out.println("Остановка № " + PHASER.getPhase());
            Thread.sleep(100);//Ждем пока пассажиры сядут и сойдут
            PHASER.arrive();//Кто не успел, тот опоздал)
        }

        System.out.println("Автобус уехал в парк.");
        PHASER.arriveAndDeregister();//Снимаем главную нить, ломаем барьер
    }

    public static class Passenger extends Thread {
        private Phaser phaser;
        private int dep;
        private int dest;

        public Passenger(Phaser phaser, int departure, int destination) {
            this.phaser = phaser;
            this.dep = departure;
            this.dest = destination;
            System.out.println(this + " ждёт на остановке № " + dep);
            this.start();
        }

        @Override
        public void run() {
            try {
                while (dep != phaser.getPhase())//Пока автобус не приедет на нужную остановку
                    phaser.awaitAdvance(phaser.getPhase());//ждем его

                Thread.sleep(10);
                phaser.register();//Регистрируем нить, которая будет участвовать в фазах
                System.out.println(this + " сел в автобус.");

                while (dest != phaser.getPhase())   //Пока автобус не приедет на нужную остановку(фазу)
                    phaser.arriveAndAwaitAdvance(); //Заявляем в каждой фазе о готовности и ждем

                Thread.sleep(10);
                phaser.arriveAndDeregister();   //Отменяем регистрацию на нужной фазе
                System.out.println(this + " покинул автобус.");
            } catch (InterruptedException e) {
            }
        }

        @Override
        public String toString() {
            return "Пассажир{" + dep + " -> " + dest + '}';
        }
    }
}

import java.util.concurrent.Phaser;

public class NewRace {
    private static final Phaser START = new Phaser(8);
    private static final int trackLength = 500000;

    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 5; i++) {
            new Thread(new Car(i, (int) (Math.random() * 100 + 50))).start();
            Thread.sleep(1000);
        }

        Thread.sleep(1000);
        System.out.println("На старт!");
        START.arriveAndDeregister();
        Thread.sleep(1000);
        System.out.println("Внимание!");
        START.arriveAndDeregister();
        Thread.sleep(1000);
        System.out.println("Марш!");
        START.arriveAndDeregister();
    }

    public static class Car implements Runnable {
        private int carNumber;
        private int carSpeed;

        public Car(int carNumber, int carSpeed) {
            this.carNumber = carNumber;
            this.carSpeed = carSpeed;
        }

        @Override
        public void run() {
            try {
                System.out.printf("Автомобиль №%d подъехал к стартовой прямой.n", carNumber);
                START.arriveAndDeregister();
                START.awaitAdvance(START.getPhase());
                Thread.sleep(trackLength / carSpeed);
                System.out.printf("Автомобиль №%d финишировал!n", carNumber);
            } catch (InterruptedException e) {
            }
        }
    }
}