ПКРПСиБД LAB5 Бычков А.С. (Лабораторная работа 5)
Описание файла
Файл "ПКРПСиБД LAB5 Бычков А.С." внутри архива находится в папке "Лабораторная работа 5". Документ из архива "Лабораторная работа 5", который расположен в категории "". Всё это находится в предмете "распределённые ис и базы данных" из 9 семестр (1 семестр магистратуры), которые можно найти в файловом архиве НИУ «МЭИ» . Не смотря на прямую связь этого архива с НИУ «МЭИ» , его также можно найти и в других разделах. Архив можно найти в разделе "лабораторные работы", в предмете "распределённые ис и базы данных" в общих файлах.
Онлайн просмотр документа "ПКРПСиБД LAB5 Бычков А.С."
Текст из документа "ПКРПСиБД LAB5 Бычков А.С."
Национальный исследовательский институт
Московский Энергетический Институт(Технический Университет)
Институт автоматики и вычислительной техники
Кафедра Прикладной математики
Лабораторная работа №5
по дисциплине:
Проектирование крупных распределенных программных систем и баз данных
тема: «Реализация параллельного шаблона проектирования»
Выполнил:
Бычков А.С.
Москва
2012 г.
Шаблон “OBJECT POOL”
Был реализован ранее
Шаблон “THREAD POOL”
Категория
Для многопоточного программирования
Описание
Предоставляет пул потоков для обработки заданий, представленных обычно в виде очереди
Уместность применения
1) Если необходимо создать очередь которая бы выполняла задания в несколько потоков.
Преимущества, достигаемые при применении шаблона
1) Распараллеливание задач. Увеличение скорости выполнения программы.
2) Удобно регулировать затраты памяти путем увеличения или уменьшения размера пула.
Недостатки
-
Реализация
public class WorkQueue
{
private readonly int mMaxThreadNum;
private readonly PoolWorker[] mThreads;
private readonly ArrayList mQueue;
public WorkQueue(int aMaxThreadNum)
{
mMaxThreadNum = aMaxThreadNum;
mQueue = new ArrayList();
mThreads = new PoolWorker[mMaxThreadNum];
for (int i = 0; i < mMaxThreadNum; i++)
{
mThreads[i] = new PoolWorker(mQueue);
mThreads[i].Start();
}
}
public void execute(ThreadStart task)
{
lock (mQueue)
{
mQueue.Add(task);
Monitor.Pulse(mQueue);
}
}
private class PoolWorker
{
private Thread mThread;
private ArrayList queue;
public PoolWorker(ArrayList aQueue)
: base()
{
queue = aQueue;
mThread = new Thread(this.run);
}
public void Start()
{
mThread.Start();
}
public void Join()
{
mThread.Join();
}
public void run()
{
ThreadStart task;
while (true)
{
lock (queue)
{
while (queue.Count == 0)
{
Monitor.Wait(queue);
}
task = (ThreadStart)queue[0];
queue.RemoveAt(0);
}
try
{
task();
}
catch (Exception e)
{
}
}
}
}
}
class Program
{
private static int counter = 40;
static int fib(int n)
{
if (n == 0)
{
return 0;
}
if (n == 1 || n == 2)
{
return 1;
}
else
{
return fib(n - 1) + fib(n - 2);
}
}
static void test()
{
int n = counter;
Console.Out.WriteLine("WILL CALCULATE FIB NUMBER " + n);
Console.Out.WriteLine("FIB NUMBER " + n + " IS " + fib(n));
counter+=5;
}
static void Main(string[] args)
{
WorkQueue queue = new WorkQueue(3);
for (int i = 0; i < 3; i++)
{
queue.execute(test);
}
Console.ReadLine();
}
}
Шаблон “LEADER/FOLLOWER”
Категория
Для многопоточного программирования
Описание
Позволяет распределять вычисления по узлам
Уместность применения
1) Если громоздкую задачу можно разделить на несколько подзадач поменьше
Преимущества, достигаемые при применении шаблона
1) Уменьшение времени выполнения задачи.
2) Легче сделать систему отказоустойчивой (модульность).
Недостатки
2) Сложность реализации
Реализация
public class FibMaster
{
public static int calcFib(int n)
{
if (n == 0)
{
return 0;
}
if (n == 1 || n == 2)
{
return 1;
}
FibSlave slave1 = new FibSlave(n - 1);
FibSlave slave2 = new FibSlave(n - 2);
Thread thread1 = new Thread(slave1.calc);
Thread thread2 = new Thread(slave2.calc);
thread1.Start();
thread2.Start();
thread1.Join();
thread2.Join();
return slave1.getResult() + slave2.getResult();
}
}
public class FibSlave
{
private int result;
private int n;
public int getResult()
{
return result;
}
public FibSlave(int n)
{
this.n=n;
}
public static int fib(int n)
{
if (n == 0)
{
return 0;
}
if (n == 1 || n == 2)
{
return 1;
}
else
{
return fib(n - 1) + fib(n - 2);
}
}
public void calc()
{
result = fib(n);
}
}
class Program
{
static void Main(string[] args)
{ int n=40;
int res=FibMaster.calcFib(n);
System.Console.WriteLine("FIB NUMBER "+n+" is "+ res);
System.Console.ReadLine();
}
}
Шаблон “SHEDULER”
Категория
Для многопоточного программирования
Описание
Шаблон проектирования, обеспечивающий механизм реализации политики планирования, но при этом не зависящий ни от одной конкретной политики. Управляет порядком, в соответствии с которым потокам предстоит выполнить последовательный код, используя для этого объект, который явным образом задаёт последовательность .
Уместность применения
1) Несколько потоков могут потребовать доступ к ресурсу одновременно, и только один поток в какой-то момент времени может осуществить доступ к ресурсу.
2) Согласуясь с требованиями программы, потоки должны осуществлять доступ к ресурсу в определенном порядке.
Реализация
public interface ISchedulerOrdering
{
Boolean ScheduleBefore(ISchedulerOrdering s);
}
public class Printer
{
private static Int32 mID = 0;
private Scheduler _scheduler = new Scheduler();
public void Print(SheduledFibSlave fibCalculation)
{
Int32 id = ++mID;
try
{
Console.WriteLine(String.Format(@"{0}: enter scheduler", id));
_scheduler.Enter(fibCalculation);
Console.WriteLine(String.Format(@"{0}: start printing", id));
try
{
fibCalculation.doT();
}
finally
{
_scheduler.Done();
Console.WriteLine(String.Format(@"{0}: done scheduler", id));
}
}
catch (Exception) { }
}
}
public class SheduledFibSlave : FibSlave, ISchedulerOrdering
{
public SheduledFibSlave(int n)
: base(n)
{
}
public Boolean ScheduleBefore(ISchedulerOrdering s)
{
if (s is SheduledFibSlave)
{
return this.n > ((SheduledFibSlave)s).n;
}
else
{
return false;
}
}
public void doT()
{
calc();
Console.Out.WriteLine("TESTING FIB FOR N = "+this.n);
Console.Out.WriteLine("RESULT FOR "+this.n+" is "+getResult());
}
}
public class Scheduler
{
// Объект синхронизации потоков
private AutoResetEvent _event = new AutoResetEvent(false);
// Устанавливается в null, если управляемый объектом Scheduler ресурс не занят.
private Thread _runningThread;
/// Потоки и их запросы ожидающие выполнения
private Dictionary
/// Метод вызывается перед тем, как поток начнет использовать уравляемый ресурс.
/// Метод не выполняется до тех пор пока управляемый ресур не освободиться и объект
/// не примет решение, что подошла очередь выполнения этого запроса
public void Enter(ISchedulerOrdering s)
{
var thisThread = Thread.CurrentThread;
lock (this)
{
// Определяем не занят ли планировщик
if (_runningThread == null)
{
// Немедленно начинаем выполнение поступившего запроса
_runningThread = thisThread;
return;
}
_waiting.Add(thisThread, s);
}
lock (thisThread)
{
//Блокируем поток до тех пор, пока планировщик не решит сделать его текущим
while (thisThread != _runningThread)
{
_event.WaitOne();
_event.Set(); // даем возможность другим потокам проверить своё состояние
Thread.Sleep(1);
}
_event.Reset();
}
lock (this)
{
_waiting.Remove(thisThread);
}
}
/// Вызов метода указывает на то, что текущий поток завершил работу
/// и управляемый ресурс освободился
public void Done()
{
lock (this)
{
if (_runningThread != Thread.CurrentThread)
throw new ThreadStateException(@"Wrong Thread");
Int32 waitCount = _waiting.Count;
if (waitCount <= 0)
{
_runningThread = null;
}
else if (waitCount == 1)
{
_runningThread = _waiting.First().Key;
_waiting.Remove(_runningThread);
_event.Set();
}
else
{
var next = _waiting.First();
foreach (var wait in _waiting)
{
if (wait.Value.ScheduleBefore(next.Value))
{
next = wait;
}
}
_runningThread = next.Key;
_event.Set();
}
}
}
}
/// Вспомогательный класс
static partial class ConvertTo
{
/// Получить первый элемент коллекции
public static KeyValuePair
{
foreach (var item in collection)
{
return item;
}
throw new ArgumentException();
}
}
public class Example01
{
private Printer _printer;
public void Run()
{
Console.WriteLine(@"Press any key for start, and press again forfinish");
Console.ReadKey();
_printer = new Printer();
new Thread(Thread1).Start();
new Thread(Thread2).Start();
new Thread(Thread3).Start();
Console.ReadKey();
}
private void Thread1()
{
var msg1 = new SheduledFibSlave(38);
var msg2 = new SheduledFibSlave(40);
var msg3 = new SheduledFibSlave(39);
_printer.Print(msg1);
_printer.Print(msg2);
_printer.Print(msg3);
}
private void Thread2()
{
var msg4 = new SheduledFibSlave(15);
var msg5 = new SheduledFibSlave(25);
_printer.Print(msg4);
_printer.Print(msg5);
}
private void Thread3()
{
var msg6 = new SheduledFibSlave(7);
var msg7 = new SheduledFibSlave(2);
_printer.Print(msg6);
_printer.Print(msg7);
}
}
class Program
{
static void Main(string[] args)
{
new Example01().Run();
Console.WriteLine(@"Press any key for end");
Console.ReadKey();
}
}
}
Шаблон “REACTOR”
Категория
Для многопоточного программирования
Описание
Шаблон проектирования, который используется для обработки сообщений, которые поступают конкурентно, в одном потоке.
Уместность применения
1) Реализация многопоточной обработки сложна и дорога
Плюсы
1) Улучшает модульность, повторную используемость и настраиваемость
2) Улучшает портируемость приложения.
Минусы
1) Тяжело отлаживать
2) Ограниченная применимость. Может быть реализован только в тех ОС, где поддерживаются “Handles”
Реализация
public interface IEventHandler
{
void HandleEvent(String data);
Queue
}
public interface IReactor
{
void RegisterHandle(IEventHandler eventHandler);
void RemoveHandle(IEventHandler eventHandler);
void HandleEvents();
}
public interface ISynchronousEventDemultiplexer
{
IList
}
public class MessageEventHandler : IEventHandler
{
private readonly Queue
public MessageEventHandler(Queue
{
mQueue = aQueue;
}
public void HandleEvent(String aData)
{
Console.WriteLine("MESSAGE RECEIVED IS "+aData);
}
public Queue
{
return mQueue;
}
}
public class Reactor : IReactor
{
private readonly ISynchronousEventDemultiplexer _synchronousEventDemultiplexer;
private readonly IDictionary
public Reactor(ISynchronousEventDemultiplexer synchronousEventDemultiplexer)
{
_synchronousEventDemultiplexer = synchronousEventDemultiplexer;
_handlers = new Dictionary
}
public void RegisterHandle(IEventHandler eventHandler)
{
_handlers.Add(eventHandler.GetHandler(), eventHandler);
}
public void RemoveHandle(IEventHandler eventHandler)
{
_handlers.Remove(eventHandler.GetHandler());
}
public void HandleEvents()
{
while (true)
{
IList
foreach (Queue
{
_handlers[listener].HandleEvent(listener.Dequeue());
}
}
}
}
public class SynchronousEventDemultiplexer : ISynchronousEventDemultiplexer
{
public IList
{
var queues =
new List
where queue.Count > 0
select queue);
return queues;
}
}
static void Main(string[] args)
{
Queue
Queue
IEventHandler client1 = new MessageEventHandler(queueA);
IEventHandler client2 = new MessageEventHandler(queueB);
ISynchronousEventDemultiplexer synchronousEventDemultiplexer = new SynchronousEventDemultiplexer();
Reactor dispatcher = new Reactor(synchronousEventDemultiplexer);
Thread th1 = new Thread(doThing);
Thread th2 = new Thread(doAnotherThing);
dispatcher.RegisterHandle(client1);
dispatcher.RegisterHandle(client2);
th1.Start(queueA);
th2.Start(queueB);
dispatcher.HandleEvents();
}
static void doThing(object queue)
{
while (true)
{
Thread.Sleep(2000);
((Queue
}
}
static void doAnotherThing(object queue)
{
while (true)
{
Thread.Sleep(1500);
((Queue
}
}
