Всем привет.
В данный момент разбираю потоки, и у меня возникло пара вопросов.
1) Почему обращение Thread.sleep(500); происходит именно так, а не t.sleep(500);, что для меня логичней было бы, т.е. почему обращаются именно к классу Thread, а не к его экземпляру.

2) Еще мне не понятна конструкция Thread.sleep(500); тем что она может вызвать исключение типа InterruptedException , ЕСЛИ бы кокой нибуть поток прервал его ожидание. Как я понял потоком который прерывает ожидание, может является ГЛАВНЫЙ поток, НО в свою очередь потоки используют процессор ВМЕСТЕ.
Тут то я и запутался окончательно.

Вот код:

Код

class NewThread implements Runnable {   Thread t;      NewThread() {   //Создать новый второй поток.  t = Thread (this, "Demo Thread");  System.out.println("Дочерний поток: " + t);    t.start();   //Стартовть поток   }  //Это точка входа во второй поток     public void run() {    try {     for(int i=0; i<5; i++) {      System.out.println("Дочерний поток: " + i);      Thread.sleep(500);     //Вызывается сам Thread, а не его экземпляр t ???    }   } catch (InterruptedException e) {     System.out.println("Прерывание дочернего потока.");    } }       class ThreadDemo {     public static void main(String args[]) {   new NewThread(); //Создать поток        try {     for(int i=0; i<5; i++) {      System.out.println("Главный поток: " + i);      Thread.sleep(1000);    }   } catch (InterruptedException e) {     System.out.println("Прерывание главного потока");      }    System.out.println("Завершение главного потока");     } }

Цитата(GIK @ 13.1.2006, 17:47 )

1) Почему обращение Thread.sleep(500); происходит именно так, а не t.sleep(500);, что для меня логичней было бы, т.е. почему обращаются именно к классу Thread, а не к его экземпляру.

Код

sleep public static void sleep(long millis)                   throws InterruptedException     Causes the [B]currently executing[/B] thread to sleep (temporarily cease execution) for the specified number of milliseconds.

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

Цитата(GIK @ 13.1.2006, 17:47 )

2) Еще мне не понятна конструкция Thread.sleep(500); тем что она может вызвать исключение типа InterruptedException , ЕСЛИ бы кокой нибуть поток прервал его ожидание. Как я понял потоком который прерывает ожидание, может является ГЛАВНЫЙ поток

Код

public class InterruptedException extends Exception Thrown when a thread is waiting, sleeping, or otherwise paused for a long time and another thread interrupts it using the interrupt method in class Thread.

- действительно ГЛАВНЫЙ (надеюсь ты под ним подразумеваешь тот который выполняется ссейчас)

Цитата(GIK @ 13.1.2006, 17:47 )

НО в свою очередь потоки используют процессор ВМЕСТЕ.

это чисто такое, общее выражение. На самом деле понятно, что если у тебя в машине 1 процессор, то в каждый момент времени выполняется код 1го треда - того самом currently executing
Выражение "используют вместе" - означает что шедуллер попеременно ставит то одного то другого и снаружи выглядит как буддто они вместе потихоньку работают.


Это сообщение отредактировал(а) redrick - 13.1.2006, 19:45

Thread.sleep(500); то же самое, что и Thread.currentThread().sleep(500), т.е. на самом деле текущий поток тормозится. А прервать его может любой другой поток, имеющий ссылку на текущий.

sleep() надо использовать если вы не предполагаете его прерывать. Если же вы хотите поток "разбудить" из другого потока, то надо использовать wait() - notify().

Цитата

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

Т.е. Thread - это всегда поток который выполняется ?

Цитата

действительно ГЛАВНЫЙ (надеюсь ты под ним подразумеваешь тот который выполняется ссейчас)

Главный поток-поток который начинается с вызова метода main.

Цитата

это чисто такое, общее выражение. На самом деле понятно, что если у тебя в машине 1 процессор, то в каждый момент времени выполняется код 1го треда - того самом currently executing Выражение "используют вместе" - означает что шедуллер попеременно ставит то одного то другого и снаружи выглядит как буддто они вместе потихоньку работают.

Понял.

Цитата

Thread.sleep(500); то же самое, что и Thread.currentThread().sleep(500), т.е. на самом деле текущий поток тормозится. А прервать его может любой другой поток, имеющий ссылку на текущий.

А как эта ссылка может реализоваться, именно в данном примере, и именно на дочерний поток?

Цитата(GIK @ 14.1.2006, 10:38 )

Т.е. Thread - это всегда поток который выполняется ?

Не совсем. Thread - это класс, а Thread.sleep(500) - это вызов статического метода у этого класса. Просто он вызывает засыпание для того потока из которого был вызван.

Цитата(GIK @ 14.1.2006, 10:38 )

А как эта ссылка может реализоваться, именно в данном примере, и именно на дочерний поток?

Так:

Код

public class ThreadTest extends Thread {   public void run()   {     try     {       Thread.sleep(60 * 60 * 1000);     }     catch(InterruptedException ex)     {       System.out.println("Thread was iterrupted: " + ex);     }   }      public static void main(String[] args)   {     ThreadTest threadTest = new ThreadTest();     threadTest.start();     try     {       Thread.sleep(1000);//Ждем пока ThreadTest запустится     }     catch(InterruptedException ex)     {}     System.out.println("Trying to interrupt ThreadTest");     threadTest.interrupt();     System.out.println("Exiting");   } }

Извяюсь что поднимаю старый вопрос, просто возникли непонятки.
Почемуто при запуске потока в экземпляре b (B b = new B(a,"super");), сразу через run(), реализуется только один поток (действие), т.е. другие, пока незакончится этот, просто бездействуют?
И еще странно что t.sleep(1000); вроде как работает, но вызова public void put() до этого момента небыло?


Это сообщение отредактировал(а) GIK - 18.1.2006, 13:28

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

А как тогда осуществляется остановка t.sleep(1000) ?
Она ведь осуществляется?
В смысле после запуска run.

Это сообщение отредактировал(а) GIK - 18.1.2006, 14:24

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

.
Понял.
А как же остальные потоки, почему они не включаются?
Мое предположение, что из-за того что run был запущен не через put(), и по этому возврата к главному потоку не было?
Добавлено @ 14:53
В смысле сразу невключаются.

У тебя в конструкторе B(A a, String s) вначале вызывается просто метод run() и соответсвенно Thread.sleep() вызывается для потока main. Потом, создается новый поток и метод run() вызывается у него, и соответвенно Thread.sleep() действует уже для него. Поскольку у тебя потоки все таки создаются в итоге, то и метод t.join() срабатывает.

Тут либо я чето недопонимаю, либо вопрос задал не правильно.
После запуска run и первой остановки t.sleep(1000) запуск put(); СРАЗУ не происходит, и вообще ничего СРАЗУ, после run () не происходит, в том числе возврат к созданию третьего экземпляра B b2 = new B();.
Вот я и думаю, что возврат к остальным потокам (действиям), происходит только после вызова через
t.start()? Т.е. только он имеет характеристики возврата к другим потокам (действиям), а метод
t.join() вообще инициализируется только после третьего экземпляра B b2 = new B();.

Программа работает так:

• создается объект A (тут ничего интерестного)
• вызывается конструктор объекта B
• в конструкторе вызывается метод run(), в котором проходимся с секундной задержкой от 5 до 1
• вызываем метод put(), который создат новый поток и запускает его
• возвращаемся из конструктора B
• на данные момент работают 2 потока main и bla1
• присваиваем ссылку на только что созданный объект, переменной b
• аналогично для b2, но там не вызываем метод run()
• на данные момент работают 2 потока main и два bla1
• ждем завершения второго потока b2.t.join()
• ждем завершения первго потока b.t.join()

Ща не могу проверить, но по памяти вывод такой:
BlaBla
BlaBla
Potok GoOOOOOOOOOO1
Potok GoOOOOOOOOOO2
Potok GoOOOOOOOOOO3
Potok GoOOOOOOOOOO4
Potok GoOOOOOOOOOO5
А потом все остально неважное.

Так вот, почему его не прерывают остальные потоки, как если бы его запустили через put(); ?

На самом деле вывод такой:

Тфу блин, перепутал цифры.
Ну да такой, ну дак что как это объяснить?

Выполняется вызов метода run() из потока main, это порождает следующий вывод:

затем происходит запуск еще 2-х потоков, потоки начинаю работать почти одновременно и потому вывод из них идет по очереди, и соответсвенно получаем:

Как объяснит тот факт, что после вызова run() напрямую, не через put(), другие потоки НЕ реализуются СРАЗУ (они ждут), через put() допустим, после вызова run() сразу происходит возврат к главному потоку, и они используют процессор как бы вместе. Но так не происходит если вызвать run() напрямую, т.е. не происходит возврата к другому(другим потокам), он использкет его один на все время затраченное на for цикле.

Или может, просто мне думать, что так оно есть и непарится, невникать в суть?
Хотя очень интересно.

Это сообщение отредактировал(а) GIK - 18.1.2006, 18:26

Как уже здесь писали, для запуска потока предназначен start(), который вызывает run(). Если программа вышла из run(), то поток умер и повторному использованию не подлежит. Метод run() напрямую не вызывают. И выяснение, что будет в случае прямого обращения к run(), имеет скорее академическую, но не практическую ценность.

У тебя есть работающий поток. В рамках одного потока команды выполняются последовательно одна за одной, можно только изменить порядок их выполнения (это делают управляющие операторы if, for, break и т.д.). Поэтому когда ты пишешь такой код: run(); то ты просто передаешь управление в метод run, далее выполняются все команды из этого метода и ты продолжаешь с того места, где закончил. Именно этим и объясняется, поведение программы в первом случае.

Теперь рассмотрим, второй случай. Ты вызываешь метод put() (все это происходит в потоке main), создаешь в этом методе объект типа Thread (кстати ты даешь ему в качестве аргумента объект который реализует интерфейс Runnable, вот тебе хороший пример использования интерфейсов. Когда разрабатывался класс Thread, никто не знал о твоем классе, но им было достаточно знать, что он будет реализовывать Runnable, значит в нем будет метод run и его можно будет вызвать.) Создал объект, после чего вызываешь метод start(), который запускает новый поток, метод start() не ждет пока поток отработает, он просто дает сигнал на запуск и возвращается. Запущенный поток, иниализируется и выполняет метод run у объекта переданного в качестве аргумента. Там уже свой поток выполнения команд, независящий от потока который его запустил. Запустивший поток может закончить свое выполнение, но это никак не влияет на этот поток.

P.S. А вообще, тебе надо почитать какую нибудь книжку, на тему многопоточного программирования.

Чтобы не плодить топики спрошу здесь:
Решил написать простой сервер чата и столкнулся с проблемой. Архитектура такова:
Есть один главный поток(принимает новые соединения), который создает объекты Connection(для каждого клиента - свой). При этом занося их в мэп вида (clientId : connection). В класс Connection инкапсулирован поток прослушивания пакетов от клиента. Если поступает пакет с сообщением, этот поток обращается к синглтону EventHandler(защищен - к нему может одновременно обращаться с запросом обработать событие только один коннект), он обращается в мэпу и рассылает сообщения клиентам. 

При таком подходе сразу возникла проблема:
Клиент может разорвать коннект или же коннект может разорваться в случае ошибки. При этом надо как-то удалить из хеш-массива запись этого коннекшена и остановить соответствующий поток. Из этого потока, в котором возникла ошибка это сделать не выйдет(или выйдет ? он же удалит сам себя из хэшмэп, но при этом будет ещё выполняться и удачно завершится. Не опасно ли это?)

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

Подскажите как лучше в данном случае построить архитектуру, и где об этом можно почитать

Вопрос снят, нашёл здесь: http://www.javatalks.ru/sutra39952.php