Lock API . Java

Lock :

Интерфейс Lock API : существует с Java 1.5.
Базовый интерфейс из lock framework, предоставляющий более гибкий подход по ограничению доступа к ресурсам/блокам нежели при использовании synchronized. Так, при использовании нескольких локов, порядок их освобождения может быть произвольный. Плюс имеется возможность пойти по альтернативному сценарию, если лок уже кем то захвачен.

Различия между Lock и synchronized блоком :

synchronized блок полностью находится внутри метода , когда мы можем в Lock API, поставить блокировку в одном методе класса , а разблокировать в другом методе этого класса.
synchronized блок не поддерживает приоритеты, любой поток может получить блокировку после освобождения метода/блока. Никакого предпочтения не может быть указано, когда в Lock API мы можем , указать свойство приоритетов . Это гарантирует, что самый длинный ожидающий поток получит доступ к блокировке .
Поток блокируется, если он не может получить доступ к synchronized блоку . Lock API предоставляет tryLock() метод. Поток получает блокировку, только если он доступен и не удерживается каким-либо другим потоком.
Поток, который находится в состоянии “waiting” для получения доступа к synchronized блоку , не может быть прерван. Lock API предоставляет метод lockInterruptibly() , позволяет прервать заблокированный поток и возобновить выполнение через брошенный java.lang.InterruptedException .

методы интерфейса Lock:

void *.lock() : получить блокировку, если она доступна; если блокировка недоступна, поток блокируется, пока блокировка не будет снята .
void *.lockInterruptibly() : похожа на lock(), но позволяет прервать заблокированный поток и возобновить выполнение через брошенный java.lang.InterruptedException .
boolean *.tryLock() : это неблокирующая версия метода lock () . Он пытается получить блокировку немедленно, возвращает true, если блокировка успешна
boolean *.tryLock (long timeout, TimeUnit timeUnit) : это похоже на tryLock (), за исключением того, что оно ожидает указанное время ожидания, прежде чем отказаться от попытки получить блокировку
void *.unlock() : разблокирует экземпляр блокировки
Lock *.readLock() : возвращает блокировку, используемую для чтения .
Lock *.writeLock() : возвращает блокировку, использованную для записи .

интерфейс Condition :

@since Java 1.5
Интерфейс, который описывает альтернативные методы стандарным wait/notify/notifyAll. Объект с условием чаще всего получается из локов через метод lock.newCondition(). Тем самым можно получить несколько комплектов wait/notify для одного объекта

await: поток ожидает, пока не будет выполнено некоторое условие и пока другой поток не вызовет методы signal/signalAll. Во многом аналогичен методу wait класса Object
signal: сигнализирует, что поток, у которого ранее был вызван метод await(), может продолжить работу. Применение аналогично использованию методу notify класса Object
signalAll: сигнализирует всем потокам, у которых ранее был вызван метод await(), что они могут продолжить работу. Аналогичен методу notifyAll() класса Object

класс ReentrantLock :

Лок на вхождение. Только один поток может зайти в защищенный блок. Класс поддерживает «честную» (fair) и «нечестную» (non-fair) разблокировку потоков. При «честной» разблокировке соблюдается порядок освобождения потоков, вызывающих lock(). При «нечестной» разблокировке порядок освобождения потоков не гарантируется, но, как бонус, такая разблокировка работает быстрее. По умолчанию, используется «нечестная» разблокировка.

класс ReentrantReadWriteLock :

Очень часто используется в многопоточных сервисах и кешах, показывая очень хороший прирост производительности по сравнению с блоками synchronized. По сути, класс работает в 2-х взаимоисключающих режимах: много reader'ов читают данные в параллель и когда только 1 writer пишет данные.

Пример ReentrantLock:

одна блокировка сразу на два метода .

public class ReentrantLockExample {

    public static void main(String[] args) throws InterruptedException {
        Resource resource = new Resource(6, 14);

        MyThread thread1 = new MyThread(resource);
        thread1.setName("firstThread");
        MyThread thread2 = new MyThread(resource);

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

        thread1.join();
        thread2.join();

        System.out.println(resource.getI());
        System.out.println(resource.getPhone());


    }


}

class MyThread extends Thread {
    private final Resource resource;

    MyThread(Resource res) {
        resource = res;
    }

    @Override
    public void run() {
        resource.incrementI();
    }
}

class Resource {
    private int i;

    public int getPhone() {
        return phone;
    }

    Resource(int i, int phone) {
        this.i = i;
        this.phone = phone;
    }

    private int phone;

    private final Lock lock = new ReentrantLock();

    void incrementI() {
        lock.lock();
        int iLocal = this.i;
        if (Thread.currentThread().getName().equals("firstThread")) {
            Thread.yield();
        }
        iLocal++;
        this.i = iLocal;

        incrementPhone();
    }

    void incrementPhone() {
        int phoneLocal = this.phone;
        if (Thread.currentThread().getName().equals("firstThread")) {
            Thread.yield();
        }
        phoneLocal++;
        this.phone = phoneLocal;
        lock.unlock();
    }

    int getI() {
        return i;
    }
}

Пример Condition:

Блокировка с условием .


public class ConditionsExample {

    private static Lock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();
    private static int bankAccount =0;

    public static void main(String[] args) {

        new AccountMinusMoney().start();
        new AccountPlusMoney().start();

    }

    static class  AccountPlusMoney extends Thread{
        @Override
        public void run() {
            lock.lock();
            bankAccount +=10;
            System.out.println("\n ------ прибавили 10 руб. \n");
            condition.signal();
            lock.unlock();
        }
    }

    static class  AccountMinusMoney extends Thread {
        @Override
        public void run() {
            if(bankAccount < 10){
                try {
                    lock.lock();
                    System.out.println("не можем списать деньги так как сумма на счету меньше 10 руб. =(");
                    System.out.println("... ждём ... другой поток ....  ");
                    condition.await();
                    lock.unlock();
                    System.out.println("... другой поток отработал ... продолжаем ! =) ");
                }catch (InterruptedException e){
                    e.printStackTrace();
                }

            }
            bankAccount -=10;
            System.out.println("\n ------ отняли 10 руб.\n");
            System.out.println();
        }
    }

}

Главная

Java

Многопоточность