Н.А. Вязовик - Программирование на Java

Процедура квантования времени поддерживает приоритеты (priority) задач. В Java приоритет представляется целым числом. Чем больше число, тем выше приоритет. Строгих правил работы с приоритетами нет, каждая реализация может вести себя по-разному на разных платформах. Однако есть общее правило – поток с более высоким приоритетом будет получать большее количество квантов времени на исполнение и таким образом сможет быстрее выполнять свои действия и реагировать на поступающие данные.

В описанном примере представляется разумным запустить дополнительный поток, отвечающий за взаимодействие с пользователем. Ему можно поставить высокий приоритет, так как в случае бездействия пользователя этот поток практически не будет занимать ресурсы машины. В случае же активности пользователя необходимо как можно быстрее произвести необходимые действия, чтобы обеспечить максимальную эффективность работы пользователя.

Рассмотрим здесь же еще одно свойство потоков. Раньше, когда рассматривались однопоточные приложения, завершение вычислений однозначно приводило к завершению выполнения программы. Теперь же приложение должно работать до тех пор, пока есть хоть один действующий поток исполнения. В то же время часто бывают нужны обслуживающие потоки, которые не имеют никакого смысла, если они остаются в системе одни. Например, автоматический сборщик мусора в Java запускается в виде фонового (низкоприоритетного) процесса. Его задача – отслеживать объекты, которые уже не используются другими потоками, и затем уничтожать их, освобождая оперативную память. Понятно, что работа одного потока garbage collector 'а не имеет никакого смысла.

Такие обслуживающие потоки называют демонами ( daemon ), это свойство можно установить любому потоку. В итоге приложение выполняется до тех пор, пока есть хотя бы один поток не- демон.

Рассмотрим, как потоки реализованы в Java.

Базовые классы для работы с потоками

Класс Thread

Поток выполнения в Java представляется экземпляром класса Thread. Для того, чтобы написать свой поток исполнения, необходимо наследоваться от этого класса и переопределить метод run(). Например,

public class MyThread extends Thread {

public void run() {

// некоторое долгое действие, вычисление

long sum=0;

for (int i=0; i<1000; i++) {

sum+=i;

}

System.out.println(sum);

}

}

Метод run() содержит действия, которые должны выполняться в новом потоке исполнения. Чтобы запустить его, необходимо создать экземпляр класса-наследника и вызвать унаследованный метод start(), который сообщает виртуальной машине, что требуется запустить новый поток исполнения и начать выполнять в нем метод run().

MyThread t = new MyThread();

t.start();

В результате чего на консоли появится результат:

499500

Когда метод run() завершен (в частности, встретилось выражение return ), поток выполнения останавливается. Однако ничто не препятствует записи бесконечного цикла в этом методе. В результате поток не прервет своего исполнения и будет остановлен только при завершении работы всего приложения.

Интерфейс Runnable

Описанный подход имеет один недостаток. Поскольку в Java множественное наследование отсутствует, требование наследоваться от Thread может привести к конфликту. Если еще раз посмотреть на приведенный выше пример, станет понятно, что наследование производилось только с целью переопределения метода run(). Поэтому предлагается более простой способ создать свой поток исполнения. Достаточно реализовать интерфейс Runnable, в котором объявлен только один метод – уже знакомый void run(). Запишем пример, приведенный выше, с помощью этого интерфейса:

public class MyRunnable implements Runnable {

public void run() {

// некоторое долгое действие, вычисление

long sum=0;

for (int i=0; i<1000; i++) {

sum+=i;

}

System.out.println(sum);

}

}

Также незначительно меняется процедура запуска потока:

Runnable r = new MyRunnable();

Thread t = new Thread(r);

t.start();

Если раньше объект, представляющий сам поток выполнения, и объект с методом run(), реализующим необходимую функциональность, были объединены в одном экземпляре класса MyThread, то теперь они разделены. Какой из двух подходов удобней, решается в каждом конкретном случае.

Подчеркнем, что Runnable не является полной заменой классу Thread, поскольку создание и запуск самого потока исполнения возможно только через метод Thread.start().

Работа с приоритетами

Рассмотрим, как в Java можно назначать потокам приоритеты. Для этого в классе Thread существуют методы getPriority() и setPriority(), а также объявлены три константы:

MIN_PRIORITY

MAX_PRIORITY

NORM_PRIORITY

Из названия понятно, что их значения описывают минимальное, максимальное и нормальное (по умолчанию) значения приоритета.

Рассмотрим следующий пример:

public class ThreadTest implements Runnable {

public void run() {

double calc;

for (int i=0; i<50000; i++) {

calc=Math.sin(i*i);

if (i%10000==0) {

System.out.println(getName()+ " counts " + i/10000);

}

}

}

public String getName() {

return Thread.currentThread().getName();

}

public static void main(String s[]) {

// Подготовка потоков Thread t[] = new Thread[3];

for (int i=0; i<t.length; i++) {

t[i]=new Thread(new ThreadTest(), "Thread "+i);

}

// Запуск потоков

for (int i=0; i<t.length; i++) {

t[i].start();

System.out.println(t[i].getName()+ " started");

}

}

}

В примере используется несколько новых методов класса Thread:

* getName()

Обратите внимание, что конструктору класса Thread передается два параметра. К реализации Runnable добавляется строка. Это имя потока, которое используется только для упрощения его идентификации. Имена нескольких потоков могут совпадать. Если его не задать, то Java генерирует простую строку вида "Thread-" и номер потока (вычисляется простым счетчиком). Именно это имя возвращается методом getName(). Его можно сменить с помощью метода setName().

* currentThread()

Этот статический метод позволяет в любом месте кода получить ссылку на объект класса Thread, представляющий текущий поток исполнения.

Результат работы такой программы будет иметь следующий вид:

Thread 0 started

Thread 1 started

Thread 2 started

Thread 0 counts 0

Thread 1 counts 0

Thread 2 counts 0

Thread 0 counts 1

Thread 1 counts 1

Thread 2 counts 1

Thread 0 counts 2

Thread 2 counts 2

Thread 1 counts 2

Thread 2 counts 3

Thread 0 counts 3

Thread 1 counts 3

Thread 2 counts 4

Thread 0 counts 4

Thread 1 counts 4

Мы видим, что все три потока были запущены один за другим и начали проводить вычисления. Видно также, что потоки исполняются без определенного порядка, случайным образом. Тем не менее, в среднем они движутся с одной скоростью, никто не отстает и не догоняет.

Введем в программу работу с приоритетами, расставим разные значения для разных потоков и посмотрим, как это скажется на выполнении. Изменяется только метод main().

public static void main(String s[]) {

// Подготовка потоков

Thread t[] = new Thread[3];

for (int i=0; i<t.length; i++) {

t[i]=new Thread(new ThreadTest(),

"Thread "+i);

t[i].setPriority(Thread.MIN_PRIORITY +

(Thread.MAX_PRIORITY -

Thread.MIN_PRIORITY)/t.length*i);

}

// Запуск потоков

for (int i=0; i<t.length; i++) {

t[i].start();

System.out.println(t[i].getName()+

" started");

}

}

Формула вычисления приоритетов позволяет равномерно распределить все допустимые значения для всех запускаемых потоков. На самом деле, константа минимального приоритета имеет значение 1, максимального 10, нормального 5. Так что в простых программах можно явно пользоваться этими величинами и указывать в качестве, например, пониженного приоритета значение 3.

Результатом работы будет:

Thread 0 started

Thread 1 started

Thread 2 started

Thread 2 counts 0

Thread 2 counts 1

Thread 2 counts 2

Thread 2 counts 3

Thread 2 counts 4

Thread 0 counts 0

Thread 1 counts 0

Thread 1 counts 1

Thread 1 counts 2

Thread 1 counts 3

Thread 1 counts 4

Thread 0 counts 1

Thread 0 counts 2

Thread 0 counts 3

Thread 0 counts 4

Потоки, как и раньше, стартуют последовательно. Но затем мы видим, что чем выше приоритет, тем быстрее отрабатывает поток. Тем не менее, весьма показательно, что поток с минимальным приоритетом ( Thread 0 ) все же получил возможность выполнить одно действие раньше, чем отработал поток с более высоким приоритетом ( Thread 1 ). Это говорит о том, что приоритеты не делают систему однопоточной, выполняющей единовременно лишь один поток с наивысшим приоритетом. Напротив, приоритеты позволяют одновременно работать над несколькими задачами с учетом их важности.

Если увеличить параметры метода (выполнять 500000 вычислений, а не 50000, и выводить сообщение каждое 1000-е вычисление, а не 10000-е), то можно будет наглядно увидеть, что все три потока имеют возможность выполнять свои действия одновременно, просто более высокий приоритет позволяет выполнять их чаще.

Демон-потоки

Демон -потоки позволяют описывать фоновые процессы, которые нужны только для обслуживания основных потоков выполнения и не могут существовать без них. Для работы с этим свойством существуют методы setDaemon() и isDaemon().

Рассмотрим следующий пример:

public class ThreadTest implements Runnable {