Atomic updates: Difference between revisions

{{task|Concurrency}}

 

# get the current value of any bucket

 

----

# At whatever rate is convenient, display (by any means) the total value and, optionally, the individual values of each bucket.

 

The display task need not be explicit; use of e.g. a debugger or trace tool is acceptable provided it is simple to set up to provide the display.

 

----

 

 

=={{header|Ada}}==

with Ada.Numerics.Discrete_Random;

end;

end loop;

The array of buckets is a protected object which controls access to its state. The task Equalize averages pairs of buckets. The task Mess_Up moves content of one bucket to another. The main task performs monitoring of the buckets state. Sample output:

<pre>

...

</pre>

 

=={{header|C}}==

 

{{libheader|pthread}}

#include <stdlib.h>

#include <stdbool.h>

for(i=0; i < N_BUCKETS; i++) pthread_mutex_destroy(bucket_mutex+i);

return EXIT_SUCCESS;

 

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

This C# implementation uses a class to hold the buckets and data associated with them. The ThreadSafeBuckets class implements thread-stability, and ensures that two threads cannot operate on the same data at the same time. Additionally, the class uses a seperate mutex for each bucket, allowing multiple operations to occur at once if they do not alter the same buckets.

 

using System.Threading; //Thread, Mutex classes

public class ThreadSafeBuckets

Random rand = new Random();

int[] Buckets;

public int BucketCount { get; private set; }

public ThreadSafeBuckets(int bucketcount)

BucketCount = bucketcount;

Buckets = new int[bucketcount];

int startingtotal = 0;

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

{

Buckets[i] = rand.Next(30);

startingtotal += Buckets[i];

{

//Transfer amount from bucket i to bucket j

if (i > BucketCount || j > BucketCount || i < 0 || j < 0 ||

i == j || amount < 0)

return;

}

public void PrintBuckets()

{

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

{

Console.Write(Buckets[i] + " ");

counter += Buckets[i];

Console.Write("= " + counter);

Console.WriteLine();

}

}

}

}

 

Sample Output:

11 17 19 1 18 1 12 35 26 16 = 156

</pre>

 

=={{header|Clojure}}==

Function returning a new map containing altered values:

(let [{f-bal from t-bal to} m

f-bal (- f-bal amt)

(if (or (neg? f-bal) (neg? t-bal))

(throw (IllegalArgumentException. "Call results in negative balance."))

Since clojure data structures are immutable, atomic mutability occurs via a reference, in this case an atom:

Now for the test:

(let [{a-val a b-val b} m

diff (- a-val b-val)

 

(.start thread-eq)

 

=={{header|E}}==

This example uses a Java AWT window to display the current state of the buckets.

 

pragma.syntax("0.9")

 

 

frame.show()

 

 

The Buckets class is thread safe and its private higher-order Lock function ensures that locks are taken out in order (to avoid deadlocks):

 

open System.Threading

 

 

do

let equalizer = Thread(equalizer bucket)

let randomizer = Thread(randomizer bucket)

Thread.Sleep 100

bucket.Print()

 

This program performs a million concurrent transfers. Typical output is:

 

[|100; 100; 100; 100; 100; 100; 100; 100; 100; 100|] = 1000

[|119; 61; 138; 115; 157; 54; 82; 58; 157; 59|] = 1000

[|208; 147; 18; 25; 178; 159; 23; 170; 36; 36|] = 1000

Press any key to continue . . .

 

=={{header|Haskell}}==

So, at any given time, the current value map is either in the MVar or being examined or replaced by one thread, but not both. The IntMap held by the MVar is a pure immutable data structure (<code>adjust</code> returns a modified version), so there is no problem from that the ''display'' task puts the value back before it is done printing.

 

 

import Control.Concurrent (forkIO, threadDelay)

forkIO (roughen buckets)

forkIO (smooth buckets)

 

Sample output:

80 ***** ** ******** *** * *** ** ** *** * * ***** **** *** *** * ** *** *** * *** * * **

40 ******** ****************** ************************************************************** *******

 

=={{header|Oz}}==

Uses a lock for every bucket. Enforces a locking order to avoid deadlocks.

 

NBuckets = 100

 

end

 

 

end

end

 

 

in

end

 

proc {Transfer From To Amount}

if From \= To then

Bigger = {Max From To}

in

in

end

end

end

 

fun {Pick}

{OS.rand} mod NBuckets + 1

end

in

thread for do {Smooth {Pick} {Pick}} end end

thread for do {Roughen {Pick} {Pick}} end end

 

Sample output:

 

=={{header|Python}}==

This code uses a ''threading.Lock'' to serialize access to the bucket set.

 

import threading

import random

# wait until all worker threads finish

t1.join()

 

Sample Output:

0 0 0 22 11 0 13 12 0 0 0 20 0 0 0 = 78

</pre>

 

=={{header|Scala}}==

object AtomicUpdates {

 

}

}

 

=={{header|Tcl}}==

<br>

{{works with|Tcl|8.5}}

package require Tk

 

tkwait window .

tsv::set still going 0

 

{{omit from|AWK}}

{{omit from|M4}}

{{omit from|Make}}

{{omit from|PlainTeX}}

{{omit from|TI-89 BASIC}} <!-- Does not have concurrency or background processes. -->

{{omit from|XSLT}}