Java Concurrency

Введение

Многопоточность. Ясно, что делать два дела одновременно и хорошо - это несомненный плюс. Вы можете ехать в метро и слушать музыку, чистить зубы и смотреть фильм. Мы живем в многопоточном мире:)

Зачем в Java?

• Используем CPU, несколько ядер
• многозадачность и производительность
• асинхронная обработка событий

В чем же разница между процессом и потоком?

• Процессы обладают собственным адресным пространством.
• Потоки работают с общей памятью.
• С потоками работает именно планировщик ОС.

Работа с потоками

Создание и запуск

Создать поток просто - мы должны отнаследоваться от Thread:

public class MyThread extends Thread {
@Override
public void run() {/*some work*/}
}

Запуск будет выглядеть как

MyThread thread = new MyThread();
thread.start();

При этом, надо обязательно помнить, что вызывать надо именно start, который уже в отдельном потоке запустит то, что вы написали в run. И да, мы можем переопределить start - но этого делать не стоит, так как там своя логика запуска вашего потока.

Внимательный читатель сразу спросит, как так, а если я хочу, чтобы мой класс был потоком, но он уже наследует какой-то другой класс. Как быть?

Тут поможет второй вариант создания потока. Это разумеется реализация интерфейса! Наш интерфейс называется Runnable.

class Task implements Runnable {
@Override
public void run() {/*some work*/}
}

Запуск:

Thread thread = new Thread(new Task());
thread.start();

Тут все просто - мы реализуем интерфейс Runnable и объект такого класса передаем в конструктор Thread. В принципе мы могли бы создать даже анонимный класс прямо в создании Thread. Т.е выглядело бы это как-то так:

Thread thread = new Thread(new Runnable() {
@Override
public void run() {/*some work*/}
});

thread.start();

Есть еще третий вариант: это создать Timer.

Timer timer = new Timer();
timer.schedule(new TimeTask {
@Override
public void run() {/*some work*/}
}, 60);

Выполнение задачи в отдельном потоке, но по таймеру.

Теперь посмотрим что будет, если я вместо start() буду вызывать именно run() метод.

    void wrongRun() {
        ThreadExample te1 = new ThreadExample("My thread", 1);
        ThreadExample te2 = new ThreadExample("My thread 2", 2);
        te1.run();
        te2.run();
    }

И увидим мы то, что все будет выполняться последовательно, без многопоточности. Сначала отработает te1, а уже после него начнет работу te2. Поэтому НЕ вызывайте run() напрямую - это бесполезно.

Жизнь потока

Итак, как создать и запустить - разобрались. Теперь - о том, что вообще с ним происходит после start.

Не вдаваясь в подробности, у потока есть состояния: RUNNABLE, WAITING, BLOCKED, TERMINATED`.

Сразу после start - поток в состоянии RUNNABLE. Он выполняется. Далее, если мы вызываем wait() - мы переводим его в состояние WAITING, откуда он может стать снова RUNNABLE, если вызвать notify() и может перейти в состояние TERMINATED.

Также из состояния RUNNABLE мы можем попасть в BLOCKED, если получим lock по монитору(lock on monitor), соответственно как только монитор освободится - мы снова перейдем в RUNNABLE. Также можно попасть в TERMINATED.

И последний вариант из RUNNABLE мы можем попасть в TERMINATED, если вызовем метод interrupt().

На схеме это выглядит как-то так:

Как видно по схеме - мы из TERMINATED не выйдем обратно, т.е если поток завершился - второй раз start() уже не вызовем. Т.е надо создать объект новый потока и запустить его заново, если нам надо это.

Почему так? А потому, что наши потоки - это объекты. А значит, запустив поток мы можем состояние нашего потока как-то изменить, например, изменить ему имя //todo пример, если у нашего объекта есть поле имя. Или что-то еще, но главное, что мы можем изменить состояние объекта. После завершения потока наш объект может быть совсем не в том виде, что при создании объекта конструктором. И если бы мы могли заново запускать отработанный поток - мы бы запускали уже объект с неизвестными данными. Поэтому - так нельзя.

Поток демон

Мы видим, что у потоков есть метод: setDaemon(). Зачем?

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

Thread join()

Join заставляет дождаться завершения потока у которого он вызван. Т.е:

    static void joinExample() throws InterruptedException {
        ThreadExample te1 = new ThreadExample("My thread", 1);
        ThreadExample te2 = new ThreadExample("My thread 2", 2);
        te1.start();
        te1.join();
        System.out.println("Main thread!");
        te2.start();
    }

Видим, что пока не завершится поток te1 - дальше ничего не происходит, ни в Main-thread, ни в te2.