Основы программирования на языке Java

Новосибирск, 2004

(С) Всеволод Рылов, все права защищены 1

Основы программирования на языке Java

Стандартная библиотека Java: java.net; Многопоточное программирование



Ключевые слова – статусКлючевые слова, которые уже известны на текущий момент:abstract defaultif private this boolean doimplements protected throw break double importpublic throws byte else instanceof return transient caseextends int short try catch final interface static void char finally long

strictfpvolatile class float native super while const for new switch continue goto package synchronized



Сетевое взаимодействие – стек протоколов Сетевая модель DoD (Internet):

Программы

TCP, UDP

IP

HTTP FTP

Ethernet

Уровень приложений (URL)

Транспортный уровень (порт)

Сетевой уровень (ip адрес)

Физический уровень

Стек протоколов



Взаимодействие в Internet

WWW Server

Client PC

Client PC

Internet FTP Server

WWWbrowser

FTP client

HTTP / TCP

HTTP / TCP & UDP

IPIP

www.yandex.ru

213.180.216.200

DNS

213.180.216.200 : 80193.124.219.107 : 12345



Работа с сетью Для работы с сетью используется пакет java.net, предоставляющий

средства: адресации в Internet (InetAddress, + средства java 1.4:

Inet4Address, Inet6Address, InetSocketAddress, SocketAddress) работы с протоколом TCP (Socket, ServerSocket, SocketOptions) работы с протоколом UDP (DatagramSocket, DatagramPacket,

MulticastSocket) работы с URL и поддержки HTTP (URL, URLConnection,

HttpURLConnection, JarURLConnection, URLDecoder, URLEncoder, ContentHandler, URLStreamHandler)

авторизации в Internet (Authenticator, PasswordAuthentication) динамической загрузки классов из сети (URLClassLoader)



Исключения пакета java.net

BindException

ConnectException

MalformedURLException

NoRouteToHostException

ProtocolExceptionSocketException

UnknownHostExceptionUnknownServiceException

IOException(from io)



Параллельный TCP серверimport java.net.*;import java.io.*;

public class TCPServer { public static void main(String[] args) throws IOException { //Создаем новый серверный Socket на порту 2048 ServerSocket s = new ServerSocket(2048); while (true) { Socket clientSocket = s.accept(); //принимаем соединение System.out.println("Получено соединение от:"+clientSocket.getInetAddress() +":"+clientSocket.getPort()); //Создаем и запускаем поток для обработки запроса Thread t = new Thread(new RequestProcessor(clientSocket)); System.out.println("Запуск обработчика..."); t.start(); } }}



Параллельный TCP сервер - продолжениеclass RequestProcessor implements Runnable

{ Socket s; //Точка установленного соединения RequestProcessor(Socket s) { this.s = s; } public void run() { try { InputStream input = s.getInputStream(); BufferedReader reader = new BufferedReader(new InputStreamReader(input)); OutputStream output = s.getOutputStream(); OutputStreamWriter writer = new OutputStreamWriter(output); String line = ""; while ( true ) { System.out.println("Ожидаем строку..."); line = reader.readLine(); if (line == null) break; System.out.println("Получена строка:"+line); writer.write("ответ от:"+s.getLocalAddress()+":"+s.getLocalPort() +" для:"+s.getInetAddress()+":"+s.getPort()+" : "+line+"\n"); writer.flush(); } writer.close(); System.out.println("Обработчик завершил работу"); } catch (IOException ex) { ex.printStackTrace(); } }}



TCP Клиент для сервераimport java.io.*;import java.net.*;

public class TCPClient { public static void main(String[] args) throws IOException { Socket s = new Socket("127.0.0.1",2048); OutputStreamWriter writer = new OutputStreamWriter(s.getOutputStream()); BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in)); BufferedReader reader = new BufferedReader(new InputStreamReader(s.getInputStream())); String line = ""; do { System.out.print("Введите строку:"); line = consoleReader.readLine(); if (line.equalsIgnoreCase("exit")) break; writer.write(line+"\n"); writer.flush(); line = reader.readLine(); System.out.println("Получен ответ:" + line); } while (true); writer.close(); }}



Многопоточное программирование Системы с одним потоком используют подход, называемый циклом

обработки событий с буферизацией (event loop with pooling) Единовременно может обрабатываться только одно событие При блокировке потока прекращается работа всей программы

В системах с многими потоками главный цикл и механизм буферизации не нужен: Единовременно возможна обработка нескольких событий Блокировка одного потока не влияет на работу других потоков

Поток может находится в нескольких состояниях: running, ready to run, suspended, resumed, blocked, stopped, terminated

Переключение потоков (context switch) происходит на основе динамически изменяющихся приоритетов (preemptive multitasking) либо на добровольной основе

Для синхронизации потоков используются мониторы



Классы для реализации многопоточностиObject

Object()getClass() : ClasshashCode() : intequals(arg0 : Object) : booleanclone() : ObjecttoString() : Stringnotify() : voidnotifyAll() : voidwait(arg0 : long) : voidwait(arg0 : long, arg1 : int) : voidwait() : voidfinalize() : void

ThreadMIN_PRIORITY : int = 1NORM_PRIORITY : int = 5MAX_PRIORITY : int = 10threadQ : Thread

ThreadGroupparent : ThreadGroupgroups[] : ThreadGroup

Runnable

run()

<<Interface>>

InterruptedException

IllegalThreadStateException

IllegalMonitorStateException IllegalStateException



Создание потоков реализация интерфейса Runnable порождение от класса Threadclass MyRunnable implements Runnable{ public void run() { //execution starts here }}…Runnable target = new MyRunnable();Thread t = new Thread (target, “one”);t.start();

class MyThread extends Thread{ public void run() { //execution starts here }}…MyThread t = new MyThread();t.setName(“two”);t.start();

Для получения текущего потока нужно воспользоваться Thread.currentThread()



Мониторы и синхронизация потоков С каждым объектом ассоциирован монитор, который можно

использовать для синхронизации доступа к объекту В один момент времени только один поток может обладать

монитором объекта Монитор объекта захватывается с помощью вызова синхронного

метода либо в синхронном блоке:

class MyClass { public synchronized void doIt() { … }}…MyClass obj = new MyClass();obj.doIt(); //Захват монитора obj

class AnotherClass { public void doIt() {…}}…AnotherClass obj = new AnotherClass();//Захват монитора objsynchronized (obj) { obj.doIt();}



Освобождение монитора Монитор объекта освобождается автоматически по завершению

выполнения синхронизированного метода или блока Монитор может быть освобожден добровольно с помощью

вызова на объекте методов wait(), wait(…). При этом вызвавший метод поток блокируется.

Для того чтобы воспользоваться семейством методов wait нужно захватить монитор объекта

Методы notify() и notifyAll() позволяют возобновить исполнение потока(ов) заблокированного(ых) на мониторе объекта с помощью вызова метода из семейства wait()

Для того чтобы вызвать notify или notifyAll нужно захватить монитор объекта

Вызов метода notify() приведет к пробуждению первого попавшегося блокированного на объекте потока по завершению синхронизированного метода или блока в котором вызван notify()



Пример синхронизации потоковclass Store { int count; public synchronized void put() {

count++;notify();

} public synchronized void get() { while (true) if (count > 0) { count--; return; } else try { wait(); } catch (InterruptedException e){…} }}

class Consumer extends Thread { Store s; Consumer (Store s) {super();this.s=s;} public void run() { s.get(); }}class Producer extends Thread { Store s; Producer (Store s) {super();this.s=s;} public void run() { s.put(); } public static void main(…) { Store s = new Store(); Consumer c = new Consumer(s); Producer p = new Producer(s); c.start(); p.start(); }}



Поток запущен

Поток ожидает пробуждения

Ожидание монитора объекта

Захвачен монитор объекта

вызван synchronzied метод

Монитор объекта освобожден

вызван wait


Вызван метод notify

notify




выход из synchronized метода

Поток запущен

Ожидание монитора объекта

вызван synchronized метод

Действие завершено

выход из synchronized метода

Поток 2 : ThreadОбектПоток 1 : Thread



Взаимная блокировка (deadlock) Поток T1 захватывает монитор объекта X Поток T2 захватывает монитор объекта Y Поток T1 пытается вызвать синхронизированный метод объекта Y

и, таким образом, блокируется Поток T2 пытается вызвать синхронизированный метод объекта X

и также блокируется T1 и T2 оказываются в состоянии deadlock

В сложном случае в состояние взаимной блокировки могут оказаться несколько потоков на нескольких мониторах объектов. Такую ситуацию очень сложно отлаживать



Управление потокамиДля управления потоком служат следующие методы класса

java.lang.Thread: start() – запускает поток на исполнение interrupt() – прерывает исполнение потока. Поток может перехватить

исключение InterruptedException pause() – приостанавливает исполнение потока (deprecated). Поток

не освобождает захваченные мониторы resume() – возобновляет исполнение потока (deprecated) stop() – останавливает поток (deprecated). Поток освобождает

захваченные мониторы destroy() – разрушает поток (not implemented) sleep() – приостанавливает исполнение потока на определенное

время join() – ожидает завершения потока



Почему pause() и resume() небезопасны Если поток T1 приостановлен с помощью pause() в момент, когда он

захватил монитор объекта X, то монитор объекта остается захваченным. Если окажется что другому потоку T2, который должен возобновить работу T1 с помощью resume(), также понадобится монитор объекта X, то потоки окажутся во взаимной блокировке.

Поэтому pause() и resume() объявлены deprecated и не должны использоваться. Вместо вызова pause() и resume() можно заставить поток, которым нужно управлять, проверять значение какой ни будь переменной в которую можно заносить значение соответствующее желаемому состоянию потока. Синхронизацию можно обеспечить с помощью монитора объекта и вызовов wait(), notify().



Почему небезопасен метод stop() Вызов метода stop() заставляет поток освободить захваченные

мониторы Если с помощью мониторов был защищен какой-ни будь ресурс

(объект), то на момент вызова stop этот ресурс (объект) может оказаться в не консистентном состоянии

При этом другие потоки могут получить доступ к этому ресурсу что скорее всего приведет к некорректной работе программы. Поэтому метод stop() объявлен deprecated

Вместо использования stop() можно, как и в случае с методами pause() и resume(), воспользоваться специальной переменной, которая должна хранить желаемое состояние потока. Поток должен проверять значение этой переменной и принимать решение о дальнейшей работе на основании этого значения.



Пул потоков (thread pool) Поток является относительно дорогим ресурсом и его создание

может быть сопряжено со значительными накладными расходами При разработке программ – серверов зачастую возникает

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

Для решения подобной проблемы можно воспользоваться «пулом потоков». Пул потоков содержит несколько потоков готовых к работе, которых можно использовать по мере необходимости

Пул потоков должен обеспечивать: возможность быстрого выделения потока для работы возможность высвобождения потока систему оповещения о статусе выполняемых задач (для

обеспечения обратной связи)



Пример реализации пула потоков

Countdown

TaskListener

+ taskInterrupted(t : Task) : void+ taskFinished(t : Task) : void+ taskStarted(t : Task) : void

Task

+ getName()+ performWork()

ThreadPoolTask

+ ThreadPoolTask()prepare()finish()interrupted()go()getName()

-listener

-task

PooledThread

+ PooledThread()- performTask()+ run()

List

(from util)

-taskQueue

Set

(from util)

ThreadPool

+ taskStarted(t : Task) : void+ taskFinished(t : Task) : void+ taskInterrupted(t : Task) : void+ addTask(t : Task) : void+ addTask(t : Task, l : TaskListener) : void+ ThreadPool()+ main(args : Logical View::java::lang::String[]) : void -taskQueue

-availableThreads



Клиент : TaskListener

: ThreadPool : List : ThreadPoolTask : PooledThreadЗадача :

Task

<<create>>

addTask(Task, TaskListener)

ThreadPoolTask(Task, TaskListener)

add()

PooledThread(Logical View::java::lang::String, List)

<<create>>

remove()

prepare( )

finish( )taskFinished(Task)

taskStarted(Task)

go( )performWork( )



Работа потоков с памятьюJVM Main memory

Master copy of V Master copy of W

Thread T2 workingmemoryThread T1 working memory

Workingcopy of V

Workingcopy of W

Workingcopy of W

Thread T1 executionengine

Thread T2 executionengine

Операции надглавнойпамятью:read, write, lock,unlock

Операциинад рабочейпамятью:use, assign,load, store

write

useassign

use

storeload

read read

load

lock/unlock

read

load

use

Date post:	13-Mar-2016
Category:	Documents
Upload:	kirtana-devaj
View:	51 times
Download:	1 times

Основы программирования на языке Java

Documents