Кофе-брейк #223. Параллелизм в Java и интерфейс Condition. Перегрузка и переопределение метода в Java

Статья из группы Random

Параллелизм в Java и интерфейс Condition

Источник: DZone Благодаря этой статье вы узнаете, как заставить потоки ожидать определенных условий с помощью интерфейса Condition. Кофе-брейк #223. Параллелизм в Java и интерфейс Condition. Перегрузка и переопределение метода в Java - 1Используя Condition, мы можем создавать механизмы, которые позволяют потокам ожидать выполнения определенных условий, прежде чем приступить к их выполнению.

public interface Condition {
 
    void await() throws InterruptedException;
 
    void awaitUninterruptibly();
 
    long awaitNanos(long nanosTimeout) throws InterruptedException;
 
    boolean await(long time, TimeUnit unit) throws InterruptedException;
 
    boolean awaitUntil(Date deadline) throws InterruptedException;
 
    void signal();
 
    void signalAll();
}
Интерфейс Condition связан с интерфейсом Lock. Поток не может взаимодействовать с Condition и его методами, если они не удерживаются с помощью Lock. Condition использует базовые механизмы Lock. Например, signal и signalAll будет использовать базовую очередь потоков, которые поддерживаются Lock, и уведомит их о пробуждении. Отличие между этими двумя интерфейсами состоит в том, что реализации Lock представляют собой высокоуровневую альтернативу блока synchronized, а реализации интерфейса Condition – это альтернатива методам notify/wait. Оба этих интерфейса входят в пакет java.util.concurrent.locks. Одной из очевидных вещей, которые реализуются с помощью Condition, является файл BlockingQueue. Рабочие потоки (worker threads) обрабатывают данные, а потоки-издатели (publisher threads) отправляют данные. Данные публикуются в очереди, рабочие потоки будут обрабатывать данные из очереди, а если данных нет в очереди, то они должны находиться в режиме ожидания. Для рабочего потока, если условие выполняется, процесс работы выглядит следующим образом:
  1. Получить lock.
  2. Проверить состояние.
  3. Обработать данные.
  4. Освободить lock.
Если условие не выполняется, процесс изменится:
  1. Получить lock.
  2. Проверить состояние.
  3. Ждем, пока не будет выполнено условие.
  4. Повторно получить lock.
  5. Обработать данные.
  6. Освободить lock.
Всякий раз, когда поток-издатель добавляет сообщение, он должен уведомлять потоки, ожидающие выполнения условия. В этом случае рабочий процесс будет таким:
  1. Получить lock.
  2. Опубликовать данные.
  3. Уведомить рабочие потоки.
  4. Освободить lock.
Очевидно, что эта функциональность уже существует через интерфейс BlockingQueue, а также реализации LinkedBlockingDeque и ArrayBlockingQueue. Давайте продолжим реализацию на конкретном примере. Взгляните на очередь сообщений:

package com.gkatzioura.concurrency.lock.condition;
 
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class MessageQueue<T> {
 
    private Queue<T> queue = new LinkedList<>();
    private Lock lock = new ReentrantLock();
    private Condition hasMessages = lock.newCondition();
 
    public void publish(T message) {
        lock.lock();
        try {
            queue.offer(message);
            hasMessages.signal(); 
        } finally {
            lock.unlock();
        }
    }
 
    public T receive() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                hasMessages.await();
            }
            return queue.poll();
        } finally {
            lock.unlock();
        }
    }
 
}
Теперь давайте задействуем все это:

 MessageQueue<String> messageQueue = new MessageQueue<>();
 
@Test
void testPublish() throws InterruptedException {
    Thread publisher = new Thread(() -> {
        for (int i = 0; i < 10; i++) {
            String message = "Sending message num: " + i;
            log.info("Sending [{}]", message);
            messageQueue.publish(message);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    });
 
    Thread worker1 = new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            try {
                String message = messageQueue.receive();
                log.info("Received: [{}]", message);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    });
 
    Thread worker2 = new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            try {
                String message = messageQueue.receive();
                log.info("Received: [{}]", message);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    });
 
    publisher.start();
    worker1.start();
    worker2.start();
 
    publisher.join();
    worker1.join();
    worker2.join();
}
Вот и все! Наши рабочие потоки обрабатывали ожидаемые сообщения и ждали, когда очередь опустеет.

Перегрузка и переопределение метода в Java

Источник: Medium В этой публикации объясняется разница между переопределением метода и перегрузкой метода в Java. Перегрузка метода и переопределение метода являются двумя важными понятиями в языке Java. Каждый из них выполняет свою роль при использовании методов в объектно-ориентированном программировании.

Перегрузка метода

В Java перегрузка метода (overload) позволяет создавать несколько методов с одинаковыми именами в одном классе. Списки параметров для методов должны быть разными (то есть, они должны иметь разные типы или количество параметров). Когда вы вызываете перегруженный метод, компилятор Java выбирает версию для вызова на основе аргументов, которые вы предоставляете методу.

public class CalculateOps{
    public void add(int x) {
        // реализация метода для int
    }

    public void add(float x) {
        // реализация метода для float
    }
    public void add(int x,float y) {
        // реализация метода для int и float
    }
}

CalulateOps calculateOps=new CalculateOps()
calculateOps.add(5)// это вызовет метод первого целочисленного параметра
calculateOps.add(5.5f)// это вызовет первый метод параметра с плавающей запятой
В приведенном выше примере мы определили методы с одинаковыми именами (add), но с разными списками параметров (один принимает int, а другой — float). Когда мы вызываем add, компилятор Java определяет, какую версию метода вызывать, основываясь на аргументе, который мы ему передаем. Вы не можете объявить несколько методов с одинаковым номером и одним и тем же типом параметра, лишь создавая разные типы возвращаемого значения. Это приведет к ошибке переопределения метода.

Переопределение метода

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

public class SuperClass {
    public void test() {
        // реализация метода в суперклассе
    }
}

public class SubClass extends SuperClass {
    @Override
    public void test() {
        // реализация метода в подклассе
    }
}

SubClass subClass= new SubClass();
subClass.test();// будет вызван метод подкласса 
SuperClass superclass= new Subclass();
superclass.test()// будет вызван метод суперкласса

Можно ли переопределить статический метод в Java?

Нет, переопределение здесь невозможно. С одной стороны, на перегрузку статического метода не накладывается никаких ограничений, поскольку компилятор считает, что методы с разным списком аргументов — это разные методы. Но это не переопределение. Метод с модификатором static относится к классу, а не к его объектам (например, экземпляру класса). Для него работает статическое связывание, поэтому переопределение в дочернем классе не работает. Тем не менее, в дочернем классе можно объявить метод static с такой же сигнатурой, как в родительском. В этом случае произойдет не перегрузка и не переопределение, а затенение (shadowing). К такому методу нельзя применить аннотацию @Override и в нем нельзя использовать ключевое слово super.
Комментарии
ЧТОБЫ ПОСМОТРЕТЬ ВСЕ КОММЕНТАРИИ ИЛИ ОСТАВИТЬ КОММЕНТАРИЙ,
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ