[ Class Overview ]
Task 6: Events and Synchronization
Learning objectives
- Synchronization with the help of semaphores and other kernel objects
Task description
OOStuBS should now be extended by synchronization objects, with which threads can inform each other about various events or "wait" for events. The following synchronization objects should be created in this task:
- With the help of semaphores it is possible to synchronize application processes with each other. In addition they should be used to block application processes at a keyboard request until a key has been pressed.
- By Buzzer (alarm clock) threads can put themselves to sleep for a specified time.
To achieve this, the Waitingroom
, Semaphore
, Customer
, Organizer
, Bell
, Bellringer
, Buzzer
, Guarded_Buzzer
, Guarded_Organizer
, Guarded_Semaphore
and Guarded_Keyboard
classes must be implemented, the
Keyboard
class must be
extended and the Scheduler
,
Thread
and Watch
classes must be adapted.
The class Guarded_Scheduler
is no longer needed, since Guarded_Organizer
takes over its
task. Likewise the global Guarded_Scheduler
object
scheduler
is to be replaced by a global Guarded_Organizer
object
organizer
.
![](task6.png)
Implementation
Part a
It is best to start with the implementation of the semaphores. For this
purpose, the classes Waitingroom
, Semaphore
, Customer
, Organizer
, Guarded_Organizer
and Guarded_Semaphore
must be implemented first.
In addition, a small adjustment to Thread
is necessary. With the help
of semaphore variables you should now be able to prevent your application
processes from interfering with each other during screen output.
Part b
In the next step, you can then extend the
Keyboard
and
Guarded_Keyboard
classes
with the getkey()
method. Through this, processes block
when reading from the keyboard using a semaphore if no key has been
pressed. Extend your program that one of the processes makes keyboard
requests (and reacts to them in some visible way).
Part c
Subsequently, the classes Bell
and Bellringer
can be
implemented and tested. A global instance bellringer
should
be created from Bellringer
.
If it is clear that especially bellringer
works as it should,
you can create the classes Buzzer
and Guarded_Buzzer
. With
this you can easily create periodic processes, where a process goes to
sleep for a few milliseconds and then makes an output. You should also
prepare a suitable example for this.
Part d
From this point on, it may happen that all applications are waiting for
semaphores or buzzers and therefore there are no runnable threads.
Unlike the previous tasks, this is now an intended situation that you
should handle by making adjustments in the
Scheduler
.
Templates
We have already done the implementation of the
List
class for you.