Брюс Эккель - Философия Java3
//: concurrency/DaemonFromFactory java
// Использование ThreadFactory для создания демонов.
import java.util.concurrent.*;
import net mindview util *;
import static net.mindview.util.Print.*,
public class DaemonFromFactory implements Runnable { public void run() { try {
while(true) {
TimeUnit MILLISECONDS.sleep(lOO); print(Thread.currentThread() + " " + this);
}
} catch(InterruptedException e) { print("Interrupted");
}
}
public static void main(String[] args) throws Exception {
ExecutorService exec = Executors newCachedThreadPool(
new DaemonThreadFactory()), for(int i = 0; i < 10. i++)
exec.execute(new DaemonFromFactory()); printC'Bce демоны запущены"); TimeUnit MILLISECONDS.sleep(500); // Задержка
}
} /// ~
Каждый статический метод создания ExecutorService перегружается для получения объекта ThreadFactory, который будет использоваться для создания новых потоков.
Сделаем еще один шаг — создадим вспомогательный класс DaemonThread-PoolExecutor:
// net/mi ndvi ew/uti1/DaemonThreadPoolExecutor.java package net mindview.util; import java util.concurrent *;
public class DaemonThreadPoolExecutor extends ThreadPoolExecutor {
public DaemonThreadPoolExecutorО {
super(0, Integer MAX_VALUE. 60L. TimeUnit SECONDS.
new SynchronousQueue<Runnable>(). продолжение &
new DaemonThreadFactoryO).
}
} /// ~
Чтобы узнать, какие значения должны передаваться при вызове конструктора базового класса, я просто заглянул в исходный код Executors.java.
Чтобы узнать, является ли поток демоном, вызовите метод isDaemon(). Если поток является демоном, то все потоки, которые он производит, также будут демонами, что и демонстрируется следующим примером:
//: concurrency/Daemons.java
// Потоки, порождаемые демонами, также являются демонами
import java util.concurrent.*,
import static net mindview util Print.*,
class Daemon implements Runnable {
private Thread[] t = new Thread[10]; public void run() {
for(int i = 0; i < t length; i++) {
t[i] = new Thread (new DaemonSpawnO); t[i].startO:
printnb("DaemonSpawn " + i + " started. ");
}
for(int i = 0. i < t.length, i++)
printnb("t[" + i + "]. isDaemonO = " + t[i] isDaemonO + ");
while(true)
Thread.yieldO;
class DaemonSpawn implements Runnable { public void run() { while(true)
Thread.yieldO;
public class Daemons {
public static void main(String[] args) throws Exception { Thread d = new Thread(new DaemonO); d.setDaemon(true); d.startO;
printnbC'd.isDaemonO = " + d.isDaemonO + ". "); // Даем потокам-демонам завершить процесс запуска: TimeUnit.SECONDS.sleep(l);
}
} /* Output:
d.isDaemonO = true, DaemonSpawn 0 started, DaemonSpawn 1 started. DaemonSpawn 2 started. DaemonSpawn 3 started. DaemonSpawn 4 started. DaemonSpawn 5 started. DaemonSpawn 6 started, DaemonSpawn 7 started, DaemonSpawn 8 started. DaemonSpawn 9 started. t[0].isDaemonO = true. t[l] isDaemonO = true, t[2].isDaemonO = true, t[3].isDaemonO = true. t[4].isDaemonO = true. t[5].isDaemonO = true. t[6].isDaemonO = true. t[7].isDaemonO = true. t[8].isDaemonO = true. t[9].isDaemonO = true. *///:-
Поток Daemon переводится в режим демона, а затем порождает группу новых потоков, которые явно не назначаются демонами, но при этом все равно оказываются ими. Затем Daemon входит в бесконечный цикл, на каждом шаге которого вызывается метод yield(), передающий управление другими процессам.
Учтите, что потоки-демоны завершают свои методы run() без выполнения секций finally:
//: concurrency/DaemonsDontRunFinally.java
// Потоки-демоны не выполняют секцию finally.
import java.util.concurrent.*.
import static net.mindview.util.Print.*,
class ADaemon implements Runnable { public void run() { try {
print("Запускаем ADaemon"); TimeUnit.SECONDS.sieep(l). } catch(InterruptedException e) {
print("Выход через InterruptedException"); } finally {
print("Должно выполняться всегда?");
}
}
}
public class DaemonsDontRunFinally {
public static void main(String[] args) throws Exception { Thread t = new Thread(new ADaemonO); t.setDaemon(true). t.startO,
}
} /* Output;
Запускаем ADaemon
*///:-
Запуск программы наглядно показывает, что секция finally не выполняется. С другой стороны, если закомментировать вызов setDaemon(), вы увидите, что секция finally была выполнена.
Такое поведение верно, даже если из предыдущих описаний finally у вас сложилось обратное впечатление. Демоны завершаются «внезапно», при завершении последнего не-демона. Таким образом, сразу же при выходе из main() JVM немедленно прерывает работу всех демонов, не соблюдая никакие формальности. Невозможность корректного завершения демонов ограничивает возможности их применения. Обычно объекты Executor оказываются более удачным решением, потому что все задачи, находящиеся под управлением Executor, могут быть завершены одновременно.
Варианты кодирования
Во всех предшествующих примерах все классы задач реализовали интерфейс Runnable. В очень простых случаях можно использовать альтернативное решение с прямым наследованием от Thread:
//• concurrency/SimpleThread.java // Прямое наследование от класса Thread.
public class SimpleThread extends Thread { private int countDown = 5; private static int threadCount = 0. public SimpleThreadO {
// Сохранение имени потока
super(Integer.toStri ng(++threadCount)).
startO.
}
public String toStringO {
return "#" + getNameO + "(" + countDown + "), ";
}
public void run() {
while(true) {
System out print(this). if(--countDown == 0) return,
}
}
public static void main(String[] args) { for(int i = 0, i < 5, i++) new SimpleThreadO.
}
} /* Output
#1(5). #1(4). #1(3). #1(2). #1(1). #2(5). #2(4). #2(3). #2(2). #2(1). #3(5). #3(4). #3(3). #3(2). #3(1). #4(5). #4(4), #4(3). #4(2). #4(1). #5(5). #5(4). #5(3). #5(2). #5(1).
Чтобы задать объектам Thread имена, вы вызываете соответствующий конструктор Thread. Имя читается в методе toStringO при помощи getName().
Также иногда встречается идиома самоуправляемой реализации Runnable:
// concurrency/SelfManaged.java
// Реализация Runnable. содержащая собственый объект Thread
public class SelfManaged implements Runnable { private int countDown = 5. private Thread t = new Thread(this). public SelfManagedO { t startO. } public String toStringO {
return Thread currentThreadO .getNameO + "(" + countDown + "). ";
}
public void run() {
while(true) {
System out print(this). if(--countDown == 0) return.
}
}
public static void main(Stnng[] args) { for(int i = 0. i < 5. i++) new SelfManagedO,
}
Thread-0(5) Thread-1(4) Thread-2(3) Thread-3(2) Thread-4(1) */// ~
В целом происходящее не так уж сильно отличается от наследования от Thread, разве что синтаксис получается чуть более громоздким. Однако реализация интерфейса позволяет наследовать от другого класса, тогда как в варианте с Thread это невозможно.
Обратите внимание на вызов start() в конструкторе. Приведенный пример очень прост, поэтому, скорее всего, в нем такое решение безопасно, но вы должны знать, что запуск потоков в конструкторе может создать изрядные проблемы — до завершения конструктора может быть запущена на выполнение другая задача, которая обратится к объекту в нестабильном состоянии. Это еще одна причина, по которой использование Executor предпочтительнее явного создания объектов Thread.
Иногда бывает разумно спрятать потоковый код внутри класса с помощью внутреннего класса, как показано здесь:
// concurrency/ThreadVariations java
// Создание потоков с использованием внутренних классов.
import java.util.concurrent.*,
import static net mindview.util.Print.*;
// Используем именованный внутренний класс, class InnerThreadl {
private int countDown = 5; private Inner inner, private class Inner extends Thread { Inner(String name) { super(name); startO,
}
public void run() { try {
while(true) {
print(this);
if(--countDown == 0) return; sleep(lO);
}
} catchdnterruptedException e) { »print("interrupted"):
}
}
public String toStringO {
return getNameO + ": " + countDown;
>
}
public InnerThreadKString name) { inner = new Inner(name);
Thread-0(4), Thread-КЗ), Thread-2(2), Thread-3(1),
Thread-1(5). Thread-2(4). Thread-3(3). Thread-4(2).
Thread-0(3), Thread-1(2), Thread-2(1), Thread-4(5),
Thread-0(2). Thread-Id). Thread-3(5). Thread-4(4),
Thread-Od). Thread-2(5). Thread-3(4), Thread-4(3).
// Используем безымянный внутренний класс: class InnerThread2 {
private int countDown = 5; private Thread t;
public InnerThread2(String name) { t = new Thread(name) {
public void run() { try {
while(true) {
print(this).
if(--countDown == 0) return, sleep(lO).
}
} catch(InterruptedException e) {
printCsleepO interrupted");
}
}
public String toStringO {
return getNameO + ". " + countDown;
}
}:
t startO;
}
}
// Используем именованную реализацию Runnable. class InnerRunnablel {
private int countDown = 5; private Inner inner,
private class Inner implements Runnable { Thread t;
Inner(String name) {
t = new Thread(this. name); t.startO;
}
public void runO { try {
while(true) {
print(this);
if(--countDown == 0) return; Ti mellnit .MILLISECONDS. si eep( 10);
}
} catch(InterruptedException e) {
printCsleepO interrupted");
}
}
public String toStringO {
return t.getNameO + ". " + countDown;
}
}
public InnerRunnableKString name) { inner = new Inner(name),
// Используем анонимную реализацию Runnable-class InnerRunnable2 {
private int countDown = 5;
private Thread t;
public InnerRunnable2(String name) {
t = new Thread(new RunnableO { public void run() { try {
while(true) {
print(this);
if(--countDown == 0) return; Ti mellnit. MI LLISECONDS. s 1 eep( 10);
}
} catchdnterruptedException e) {
printCsleepO interrupted");
}
}
public String toStringO {
return Thread.currentThreadO.getNameO + ": " + countDown;
}
}. name); t.startO;
}
}
// Отдельный метод для выполнения кода в потоке: class ThreadMethod {
private int countDown = 5; private Thread t; private String name;
public ThreadMethodCString name) { this.name = name; } public void runTaskO { if(t == null) {
t = new Thread(name) {
public void run() { try {
while(true) {
print(this);
if(--countDown == 0) return; sleep(lO);
}
} catchdnterruptedException e) {
printCsleepO interrupted");
}
}
public String toStringO {
return getNameO + ": " + countDown;
}
}:
t.startO;
}
}
}
public class ThreadVariations {
public static void main(String[] args) { new InnerThreadlCInnerThreadl") ; new InnerThread2("InnerThread2"); new InnerRunnablelCInnerRunnablel");
new InnerRunnable2("InnerRunnable2"); продолжение &
new ThreadMethodC'ThreadMethod") runTaskO,
}
} ///-
InnerThreadl определяет именованный внутренний класс, производный от Thread, и создает экземпляр этого класса в конструкторе. Поступать так стоит в том случае, когда у внутреннего класса есть особые возможности (новые методы), которые могут понадобиться в других методах. Однако в большинстве случаев причина создания потока — использование функциональности класса Thread, поэтому в именованном внутреннем классе особой нужды нет. Inner-Thread2 показывает другое решение. В конструкторе создается безымянный внутренний субкласс Thread, преобразуемый восходящим преобразованием к ссылке на Thread t. Если другим методам класса понадобится обратиться к t, они смогут сделать это через интерфейс Thread, и им не нужно будет знать точный тип объекта.
