ImportJava,util.*;

class CUseEv implements Observer // Класс обозревателя

{

public void update (Observable obj, Object arg)

{

System.out.println("Notify: 1=

+ ((Integer)arg).intValue ( ));

>

>

class Notify extendsObservable // Класс наблюдаемого объекта

{

public void send (int i)

{

setChanged ( );

notifyObservers (new Integer (i));

>

}

class CThread extends Thread

{

// Класс потокового объекта

Notify notify;

int num;

boolean life;

// Ссылка на наблюдаемый объект

// Номер потокового объекта

// Признак жизни

public CThread (int Num)

{

num= Num; llfe= false;

notify= new Notify(); // Создать наблюдаемый объект

public void Start ( ) // Стартовать потоковый объект

{

If (!life) // Если потоковый объект не функционирует,

{

life= true; // то пусть живёт

thls.start(); >

>

public void Finish ( ) {llfe= false; >

public void run() // Потоковая функция

{

int n= 0; // Номер цикла выполнения потока

while (life) // Пока живёт, выполнять

{

n++;

notify.send(n); // Инициировать уведомление

try

{

Thread.sleep (50);

>

catch(InterruptedException e){>

>

System.out.println ("Thread " + num + " finished");

>

>

class TestThread // Главный класс приложения

{

public static vold main ( )

{

CUseEv useEv= new CUseEv (); // Создать объект useEv

CThread threadl- new CThread (1); // Создать потоковый объект

threadl.notify-addObserver(useEv);// Подписать обозреватель

threadl,Start (); // Запустить потоковый объект

try

{

Thread.sleep (200);

>

catch(InterruptedException e){}threadl.Finish (); // Завершить

// потоковый объект

threadl.Finish ();

>

/>*

Result:

Notify: 1= 1

Notify: i= 2

Notify: 1= 3

Notify: i= 4

Thread 1 finished

*/

9.5. Поток получил событие из объекта

Пример 9.5.1 иллюстрирует в отличие от примера 9.4.1 противополож-

ный случай, когда не потоковый объект посылает событие, а потоковому

объекту посылается событие из обычного объекта.

Пример 9.S.1. Поток получил событие из объекта.

////////////////////

/ / C #

using System;

using System.Threading;

namespace CsTEl_2

{

delegate void delEv (string st); // Тип делегата событий

class CGenEv // Класс объекта, посылающего событие потоковому объекту

{

public event delEv ev; // Событие к потоковому объекту

public void GenerateEv (string str ) // Сгенерировать событие

<

if (ev 1= null)

ev (str); // Послать событие ev

>

>

class CThread // Класс потокового объекта

{

bool received; // Признак получения события

string st;

int num;

Thread thread;

bool life;

public CThread (int Num ) {num= Num; life= false;>

~CThread ( ) {iife= false; received= false;}

public void Start ( )

{

If (!life)

{

life= true;

thread= new Thread (new ThreadStart (ThreadFunc));

thread.Start ();

} >

public void Finish ( ) {life= false;}

public void HandlerEv (string str)

{

received= true;

st= str;

>

private vold ThreadFunc ( )

{

int n= 0;

while Hife^

<" " " " ' ^"

n+ + ;

Console.WriteLine ("thread " + num + " n= " + n);

If (received)

{

received= false;

Console.WriteLine ("Поток получил событие: " +

}

Thread.Sleep (50);

>

Console.WriteLine ("Thread " + num + " finished");

>

>

class TestThread

{

static void Maln ( )

{

CThread threadl= new CThread (1);

CGenEv genEv= new CGenEv ();

// Подписать обработчик HandlerEv на событие ev

genEv.ev += new delEv (threadl.HandlerEv);

threadl.Start ();

Thread,Sleep (100);

genEv.GenerateEv ("Здравствуй");

Thread.Sleep (100);

threadl.Finish ();

>

}

I>*

Result:

thread 1 n= 1

thread 1 n= 2

thread 1 n= 3

Поток получил событие: Здравствуй

thread 1 n= 4

Thread 1 finished

* /

////////////////////

// Java и J #

|| Обработать поступившее

// событие

// Событие получено

interface ICThread

{

public void HandlerEv (String str);

>

class CGenEv // Класс объекта, посылающего событие потоковому объекту

{

ICThread ICThread; // Интерфейсная ссылка

public CGenEv (ICThread IC)

/

iCThread= IC; // Установить ссылку на потоковый объект

>

public vold GenerateEv (String str) // "Сгенерировать событие"

{

iCThread.HandlerEv(str); // Послать сообщение

>

>

class CThread extends Thread implements ICThread

{

boolean received;

String st;

int num;

boolean life;

public CThread (int Num ) <num= Num; life= false; received= false;>

public vold Start ( )

{

if (!life)

{

life= true;

this.start();

>

>

public vold Finish ( ) {life= false;}

public void HandlerEv (String str) // Обработать поступившее

{ // событие

receivedc true;

st= str;

>

public void run ()

{

int n= 0;

while (llfe)

{

n++;

System.out,println ("thread " + num + " n= " + n);

if (received)

{

received= false;

System.out.println ("The thread received message: " +

st);

>

try

{

Thread.sleep (50);

>

catch(InterruptedException e){}

>

bystem.out.println ("inread " + num + :: nnisnea");

>

>

class TestThread

{

public static void main ( )

{

CThread threadl= new CThread (1);

CGenEv genEv= new CGenEv (threadl );

try

{

threadl.Start ();

Thread.sleep (100);

>

catch(InterruptedException e){}

genEv.GenerateEv ("hello");

try

{

Thread.sleep (100);

>

catch(InterruptedException e){>

threadl.Finish ( );

>

/>*

Result:

thread 1 n= 1

thread 1 n= 2

thread 1 n= 3

The thread received message: hello

thread 1 n= 4

Thread 1 finished

*/

////////////////////

// C++/CLI

#include "stdafx.h"

using namespace System;

using namespace System::Threading;

delegate vofd delEv (String^};

ref class CGenEv // Класс объекта, посылающего событие в потоковый объект

{

public:

event de!Ev ^ev;

void GenerateEv (String ^str ) // Сгенерировать событие

<

ev (str); // Послать событие ev

>

>;

refclass CThread // Потоковый класс, объект которого получает событие

<

int num;

Thread ^thread;

bool life;

bool received;

String ^st;

public:

CThread (int Num ) {num= Num; life= false; received= false;>

~CThread ( ) {llfe= false;}

void Start ( )

{

If (llife)

{

life= true;

thread= gcnew Thread (gcnew ThreadStart (thls,

&CThread::ThreadFunc));

thread -> Start ( );

>

>

void Finish ( ) {life= false;}

void HandlerEv (String ^str) // Обработать поступившее

< // событие

received= true;

st= str;

>

void ThreadFunc ()

{

int n= 0;

while (life)

{

n++;

Console::Write ("thread {0}", num.ToString ( ));

Console::WriteLine (" n= {0}", n.ToString ());

if (received)

{

received= false;

Console::WrlteLine ("Поток получил событие: {0}", st);

>

Thread::Sleep (50);

Console::Write (Thread {0>", num.ToString ());

Console::WriteLine (" finished");

>

>;

void main ( )

{

CThread ^threadl= gcnew CThread (1);

CGenEv ^genEv= gcnew CGenEv ( );

t h r e a d l -> Start ( );

genEv -> ev += gcnew delEv (threadl, &CThread::HandlerEv);

Thread::Sieep (100);

genEv -> GenerateEv ("Здравствуй");

Thread::Sleep (100);

threadl -> Finish ();

/>*

Result:

thread 1 n= 1

thread 1 n= 2

thread 1 n= 3

Поток получил событие: Здравствуй

thread 1 n= 4

Thread 1 finished

* /

Класс CGenEv обычного объекта объявляет ссылку (или дескриптор) ev

на событие, использующее делегат delEv. Класс CGenEv содержит функцию

GenerateEv(), генерирующую событие ev. Эту функцию применяет функция

main() к объекту genEv класса CGenEv через 100 мс после его старта. Причём

функция GenerateEv() имеет аргумент "Здравствуй".

Класс CThread потокового объекта включает обработчик HandlerEv()

события ev, который подписывается на событие ev объекта genEv с помощью

делегата delEv или интерфейсной ссылки после создания этого объекта, но

перед его запуском.

Потоковый объект использует булевскую переменную received для

фиксации потоком получения события. При этом поток выдаёт на консоль

строку, подтверждающую получение сообщения.

В примере 9.5.2 рассмотрена иная реализация воздействия из объекта на объ-

ект с потоком. Здесь объект с потоком представлен как обозреватель, то есть

объект класса, наследующего интерфейс Observer и содержащий обработчик

update() уведомлений от наблюдаемого объекта. Такая реализация возможна

только на языках Java и J# , библиотека которых включает требуемый класс

Observable и интерфейс Observer.

Пример 9.5.2. Поток получил уведомление из наблюдаемого объекта.

////////////////////

// Java и J#