Metered concurrency: Difference between revisions
Undo revision 8472 by Special:Contributions/CzhBiz (User talk:CzhBiz)
mNo edit summary |
(Undo revision 8472 by Special:Contributions/CzhBiz (User talk:CzhBiz)) |
||
Line 1:
{{task}}
The goal of this task is to create a [http://en.wikipedia.org/wiki/Counting_semaphore counting semaphore] used to control the execution of a set of concurrent units. This task intends to demonstrate coordination of active concurrent units through the use of a passive concurrent unit. The operations for a counting semaphore are ''acquire'', ''release'', and ''count''. Each active concurrent unit should attempt to acquire the counting semaphore before executing its assigned duties. In this case the active concurrent unit should report that it has acquired the semaphore. It should sleep for 2 seconds and then release the semaphore.
Line 32:
entry Acquire when Lock_Count < Max is
begin
Lock_Count := Lock_Count
end Acquire;
Line 79:
Sleep_Time := Sleep;
end Start;
--Acquire the lock. The task
Lock.Acquire;
Put_Line("Task #" & Positive'Image(My_Id) & " acquired the lock.");
-- Suspend the task for Sleep_Time seconds
delay Sleep_Time;
-- Release the lock. Release is unconditional and happens without suspension
Lock.Release;
end Worker;
-- Create an array of 5 Workers
type Staff is array(Positive range 1..5) of Worker;
Crew : Staff;
begin
for I in Crew'range loop
Crew(I).Start(2.0, I);
end loop;
end Semaphores_Main;
==[[E]]==
[[Category:E]]
This semaphore slightly differs from the task description; the release operation is not on the semaphore itself but given out with each acquisition, and cannot be invoked too many times.
def makeSemaphore(maximum :(int > 0)) {
var current := 0
def waiters := <elib:vat.makeQueue>()
def notify() {
while (current < maximum && waiters.hasMoreElements()) {
current += 1
waiters.optDequeue().resolve(def released)
when (released) -> {
current -= 1
notify()
}
}
}
def semaphore {
to acquire() {
waiters.enqueue(def response)
notify()
return response
}
to count() { return current }
}
return semaphore
}
def work(label, interval, semaphore, timer, println) {
when (def releaser := semaphore <- acquire()) -> {
println(`$label: I have acquired the lock.`)
releaser.resolve(
timer.whenPast(timer.now() + interval, fn {
println(`$label: I will have released the lock.`)
})
)
}
}
def semaphore := makeSemaphore(3)
for i in 1..5 {
work(i, 2000, semaphore, timer, println)
}
==[[Java]]==
[[Category:Java]]
public class CountingSemaphore
{
private int lockCount = 0;
private int maxCount;
CountingSemaphore(int Max)
{
maxCount = Max;
}
public synchronized void acquire() throws InterruptedException
{
while( lockCount >= maxCount)
{
wait();
}
lockCount++;
}
public synchronized void release()
{
if (lockCount > 0)
{
lockCount--;
notifyAll();
}
}
public synchronized int getCount()
{
return lockCount;
}
}
public class Worker extends Thread
{
private CountingSemaphore lock;
private int id;
Worker(CountingSemaphore coordinator, int num)
{
lock = coordinator;
id = num;
}
Worker()
{
}
public void run()
{
try
{
lock.acquire();
System.out.println("Worker " + id + " has acquired the lock.");
sleep(2000);
}
catch (InterruptedException e)
{
}
finally
{
lock.release();
}
}
public static void main(String[] args)
{
CountingSemaphore lock = new CountingSemaphore(3);
Worker crew[];
crew = new Worker[5];
for (int i = 0; i < 5; i++)
{
crew[i] = new Worker(lock, i);
crew[i].start();
}
}
}
==[[Perl]]==
[[Category:Perl]]
See [http://search.cpan.org/dist/Coro/Coro/Semaphore.pm Coro::Semaphore].
| |||