Metered concurrency: Difference between revisions

 

The interface for the counting semaphore is defined in an Ada package specification:

protected type Counting_Semaphore(Max : Positive) is

entry Acquire;

Lock_Count : Natural := 0;

end Counting_Semaphore;

The ''Acquire'' entry has a condition associated with it. A task can only execute the ''Acquire'' entry when ''Lock_Count'' is less than ''Max''. This is the key to making this structure behave as a counting semaphore. This condition, and all the other aspects of ''Counting_Semaphore'' are contained in the package body.

 

------------------------

end Counting_Semaphore;

 

We now need a set of tasks to properly call an instance of ''Counting_Semaphore''.

with Ada.Text_Io; use Ada.Text_Io;

 

Crew(I).Start(2.0, I);

end loop;

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to PAR and SEMA being unimplemented}}

 

PROC job = (INT n)VOID: (

( DOWN sem ; job(2) ; UP sem ) ,

( DOWN sem ; job(3) ; UP sem )

Output:

<pre>

{{works with|BBC BASIC for Windows}}

In BBC BASIC concurrency can only be achieved by timer events (short of running multiple processes).

DIM tID%(6)

PROC_killtimer(tID%(i%))

NEXT

'''Output:'''

<pre>

=={{header|C}}==

{{works with|POSIX}}

#include <pthread.h>

#include <stdlib.h>

 

return sem_destroy(&sem);

 

=={{header|C sharp}}==

C# has built in semaphore system where acquire is called via Wait(), release with Release() and count with semaphore.CurrentCount.

using System.Threading;

using System.Threading.Tasks;

}

}

 

=={{header|D}}==

import std.stdio ;

import std.thread ;

foreach(inout c ; crew)

c.wait ;

===Phobos with tools===

Using the scrapple.tools extension library for Phobos ..

 

import tools.threads, tools.log, tools.time, tools.threadpool;

for (int i = 0; i < 10; ++i)

done.acquire;

 

=={{header|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.

 

var current := 0

def waiters := <elib:vat.makeQueue>()

for i in 1..5 {

work(i, 2000, semaphore, timer, println)

 

=={{header|EchoLisp}}==

(require 'tasks) ;; tasks library

 

;; run 10 // tasks

(for ([i 10]) (task-run (make-task task i ) (random 500)))

{{out}}

<pre>

=={{header|Erlang}}==

In this implementation the semaphore is handled as its own process. Taking advantage of erlang's receive queues, which act as a FIFO queue for 'acquire' requests. As workers come online and request the semaphore they will receive it in order. 'receive' has the effect of pausing the process until a message is matched, so there's no idle looping.

-module(metered).

-compile(export_all).

lists:foreach(fun (P) -> receive {done, P} -> ok end end, Pids),

stop(Sem).

 

=={{header|Euphoria}}==

sems = {}

constant COUNTER = 1, QUEUE = 2

while length(task_list())>1 do

task_yield()

 

Output:

 

=={{header|Factor}}==

concurrency.semaphores formatting kernel sequences threads ;

 

] with-semaphore

"task %d released\n" printf

{{out}}

<pre>

task 9 released

</pre>

 

=={{header|Go}}==

 

A couple of other concurrency related details used in the example are the log package for serializing output and sync.WaitGroup used as a completion checkpoint. Functions of the fmt package are not synchronized and can produce interleaved output with concurrent writers. The log package does nice synchronization to avoid this.

 

import (

rooms.release()

studied.Done() // signal that student is done

Output for this and the other Go programs here shows 10 students studying immediately, about a 2 second pause, 10 more students studying, then another pause of about 2 seconds before returning to the command prompt. In this example the count values may look jumbled. This is a result of the student goroutines running concurrently.

 

===Sync.Cond===

A more traditional approach implementing a counting semaphore object with sync.Cond. It has a constructor and methods for the three operations requested by the task.

 

import (

studyRoom.release()

studied.Done()

 

=={{header|Groovy}}==

Solution:

private int count = 0

private final int max

 

synchronized int getCount() { count }

 

Test:

(1..12).each { threadID ->

Thread.start {

}

}

 

Output:

The QSem (quantity semaphore) waitQSem and signalQSem functions are the Haskell acquire and release equivalents, and the MVar (synchronizing variable) functions are used to put the workers statuses on the main thread for printing. Note that this code is likely only compatible with GHC due to the use of "threadDelay" from Control.Concurrent.

 

 

worker :: QSem -> MVar String -> Int -> IO ()

worker q m n = do

 

main :: IO ()

main = do

 

==Icon and {{header|Unicon}}==

 

Icon doesn't support concurrency. A Unicon solution is:

n := integer(A[1] | 3) # Max. number of active tasks

m := integer(A[2] | 2) # Number of visits by each task

 

every wait(!threads)

 

Sample run:

->

</pre>

 

=={{header|Java}}==

private int lockCount = 0;

private int maxCount;

 

}

 

=={{header|Julia}}==

function acquire(num, sem)

sleep(rand())

 

runsem(4)

Sleeping and running 4 tasks.

Task 4 waiting for semaphore

 

=={{header|Kotlin}}==

 

import java.util.concurrent.Semaphore

}

}

 

Sample output:

=={{header|Logtalk}}==

Using Logtalk's multi-threading notifications, which use a per-object FIFO message queue, thus avoiding the need of idle-loops. Works when using SWI-Prolog, XSB, or YAP as the backend compiler.

:- object(metered_concurrency).

 

 

:- end_object.

Output:

| ?- metered_concurrency::run.

Worker 1 acquired semaphore

Worker 4 releasing semaphore

yes

 

=={{header|Nim}}==

 

This program must be compiled with option <code>--threads:on</code>.

 

type SemaphoreError = object of CatchableError

for n in 0..9: createThread(threads[n], task, n)

threads.joinThreads()

 

{{out}}

Using Nim standard mechanisms provided by module “locks”. As for the previous program, it must be compiled with option <code>--threads:on</code>.

 

 

type Semaphore = object

for n in 0..9: createThread(threads[n], task, n)

threads.joinThreads()

 

{{out}}

If the channel is empty a task will wait until it is no more empty.

 

 

Object Class new: Semaphore(ch)

 

Semaphore method: acquire @ch receive drop ;

 

Usage :

 

while( true ) [

s acquire "Semaphore acquired" .cr

| s i |

Semaphore new(n) ->s

 

=={{header|Oz}}==

Counting semaphores can be implemented in terms of mutexes (called "locks" in Oz) and dataflow variables (used as condition variables here). The mutex protects both the counter and the mutable reference to the dataflow variable.

fun {NewSemaphore N}

sem(max:N count:{NewCell 0} 'lock':{NewLock} sync:{NewCell _})

for I in 1..10 do

{StartWorker I}

 

=={{header|Perl}}==

=={{header|Phix}}==

{{trans|Euphoria}}

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(for U 4 # Create 4 concurrent units

(unless (fork)

(wait 2000)

(prinl "Unit " U " releasing the semaphore") )

 

=={{header|PureBasic}}==

After a thread has completed it releases the Semaphore and a new thread will

be able to start.

#Parallels=3

Global Semaphore=CreateSemaphore(#Parallels)

WaitThread(i)

EndIf

Sample output

<pre>Thread #0 active.

Python threading module includes a semaphore implementation. This code show how to use it.

 

import threading

 

running = 0

for t in workers:

 

=={{header|Racket}}==

 

#lang racket

 

(printf "Job #~a done\n" i)

(semaphore-post sema)))))

 

=={{header|Raku}}==

(formerly Perl 6)

Uses a buffered channel to hand out a limited number of tickets.

has $.tickets = Channel.new;

method new ($max) {

}

await @units;

{{out}}

<pre>unit 0 acquired

Counting semaphores are built in:

 

4 semaphore as sem

 

group

10 each drop worker

 

Thread joining is automatic by default.

 

This one uses SizedQueue class from the standard library since it blocks when the size limit is reached. An alternative approach would be having a mutex and a counter and blocking explicitly.

require 'thread'

 

threads.each(&:join)

 

=={{header|Rust}}==

//! Rust has a perfectly good Semaphore type already. It lacks count(), though, so we can't use it

//! directly.

}

 

{{out}}

<pre>

 

=={{header|Scala}}==

private var lockCount = 0

 

}

}

 

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

Uses the Thread package, which is expected to form part of the overall Tcl 8.6 release.

package require Thread

 

foreach t $threads {

thread::release -wait $t

 

=={{header|UnixPipes}}==

The number of concurrent jobs can be set by issuing that many echo '1''s at the begining to sem.

 

 

acquire() {

( acquire < sem ; job 3 ; release > sem ) &

 

 

=={{header|Visual Basic .NET}}==

This code shows using a local semaphore. Semaphores can also be named, in which case they will be shared system wide.

 

sem.WaitOne() 'Blocks until a resouce can be aquired

Dim oldCount = sem.Release() 'Returns a resource to the pool

 

=={{header|Wren}}==

{{libheader|Wren-queue}}

In Wren, only one fiber can be run at a time but can yield control to another fiber and be resumed later. Also other tasks can be scheduled to run when a fiber is suspended by its sleep method. The following script (with 6 tasks) therefore takes just over 4 seconds to run rather than 12.

import "timer" for Timer

 

class CountingSemaphore {

// call the first one

tasks[0].call(1)

 

{{out}}

=={{header|zkl}}==

Semaphores are built in.

name.println(" wait"); sem.acquire();

name.println(" go"); Atomic.sleep(2);

// start 3 threads using the same semphore

s:=Thread.Semaphore(1);

{{out}}

<pre>