Concurrency by liaoxiuli3



  Important and difficult
(Ada slides copied from Ed
  Asynchronous concurrency
Two threads of computation proceed
 “simultaneously”. Don’t know the
 relative timing in advance.
Threads must communicate, and they
 must sometimes synchronize.
• Non-deterministic. What happens may
  depend on the relative timing. A
  program is correct only if it is correct for
  all possible interleavings of steps. For 2
  thread each with N steps there are
  C(2N,N) ≈ 2N interleavings.
• Interaction with multi-process OS (or
  not?). Scott has a detailed account.
• Low-level architecture and peripherals.
  Universal, but below the PL level.
• Multiple CPUs. Not uncommon, but rarely
  enough for all the threads you want.
• Pseudo-parallelism. “Time sharing”. CPU
  executes some of one thread, then changes
  to another.
• Computers on a network. Languages for
  distributed system are different, reflecting the
  high cost of communication.
         Common forms of
• Mutual exclusion.
• Condition synchronization.
• Barriers
         Mutual exclusion
Only one thread at a time can enter its
  critical section.
• Shared resources: e.g. printer, terminal,
• Shared memory.
            Race condition
Thread A:             Thread B:
X = X+10;              X = X+20;
A1: LOAD R1, X       B1: LOAD R2,X
A2: ADD R1, 10       B2: ADD R2, 20
A3: STORE R1, X       B3: STORE R2,X
     Race condition (cntd)
                  X = 10   R1   R2
A1: LOAD R1,X              10
B1: LOAD R2,X                   10
A2: ADD R1, 10             20
B2: ADD R2, 20                  30
B3: STORE R2, X     30
A3: STORE R1,X      20
   Condition synchronization
Suspend the thread until some condition
  is met.
• In a complex calculation, thread A may
  have to wait for the result of B in order
  to continue.
• In a web search engine, a thread
  requests a web page from a server,
  then waits until the page arrives
Make sure that all the threads have
  reached a “barrier point” before any
  proceed past it.
E.g. in simulation of a physical system,
  have a thread for each physical part,
  compute behavior over a time step.
  Make sure that all parts finish one time
  step before any proceed to the next.
             Tasks in Ada
Individual tasks and task types.
Task declaration
    task boss;
    task body boss is begin … end
Task type declaration
  type task worker;
  type Worker_id is access worker;
  task body worker is begin … end
         Task Declarations
• Individual tasks and task types
• A task can be a component of a composite
• The number of tasks in a program is not fixed
  at compile time.
   W1, W2: worker;
    type Crew is array (integer range <>)
                                  of worker;
    First_Shift: Crew(1 .. 10);
       Task Activation:
 When does a task start running?
• Individual task at start of program.
• If statically allocated, at next begin.
• If dynamically allocated, at the point of allocation.
 W1, W2: Worker;
 Joe: Worker_ID := new Worker;
                               // starts working at once.
 Third_Shift: Crew(1..N) of Worker
  begin \\ start W1, W2, Third_Shift
  end ; \\ wait for W1, W2, Third_Shift, to complete
          \\ (not Joe).
            Task Services
• A task can perform some actions (entries) on
  request from another task.
• The declaration of the task specifies the
  available entries.
• A task can also execute actions on its own
     task type Device is
       entry Read (X: out Integer);
       entry Write(X: Integer);
     end Device;
Synchronization: Rendezvous
• Caller makes explicit request: entry call.
• Callee (server) states its availability; accept
• If server is not available, caller blocks and
  queues up on the entry for later service.
• If both present and ready, parameters are
  transmitted to server.
• Server performs body of entry
• Out parameters are transmitted to caller.
• Both caller and server continue execution.
Example: 1 item shared buffer
task Buffer is
   entry Put(X: in Item);
   entry Get(X: out Item);
task body Buffer is
   V: Item;
     accept Put(X: in Item) do V := X; end Put;
     accept Get(X: in Item) do X := V; end Get;
  end loop;
end Buffer:
To call: Buffer.Put(…), Buffer.Get(…)
  Example: Mutual Exclusion
task type Mutex is
   entry Lock();
   entry Unlock();
task body Mutex is
begin loop
        accept Lock() do ; end Lock;
        accept Unlock() do ; end Unlock;
       end loop; end Mutex;
task XMutex: Mutex;
Thread A              Thread B
XMutex.Lock();        XMutex.Lock();
X := X+10;            X := X+20;
XMutex.Unlock();      XMutex.Unlock();
         Delays and Time
• A delay statement can be executed
  anywhere at any time to make current
  task quiescent for a stated duration or
  until a specified time:
     delay 0.2; -- unit is seconds
                  -- type is Duration.
     delay until Noon;
  Conditional communication
• Need to protect against excessive delays,
  deadlock, starvation, caused by missing or
  malfunctioning task
• Timed entry: Caller waits for rendezvous a
  stated amount of time:
       D.Write(997); -- D is a task
      or delay 0.2
    end select
Conditional communication (ii)
Conditional entry call: Caller ready for
  rendezvous only if no one else is queued and
  rendezvous can begin at once.
  else Put_Line(“Device busy”);
end select;

Print message if call cannot be accepted
   Conditional communication (iii)
The server may accept a call only if the internal state of the task is
 when not full => accept Write(V: integer);
 when not empty => accept Read(V: integer);
  delay 0.2;
end select

If several guards are satisfied and callers are present, then any one
    of the calls may be accepted: Non-determinism.
   Readers/Writers problem
Problem: Various tasks want to read and
  write to the same data (a chunk of data
  of some size).
Writers must be mutually exclusive with
  one another and with readers, but
  readers need not be.
 accept with and without body
accept Write do V := X; end
  -- caller must wait until “end”
accept Start;
  -- caller must synchronize but need not
  wait after acceptance.
          Common barrier
Problem: N threads must move through
  iterations of a loop in lock-step.
  for I in 1 .. NThreads) loop
     accept finish; end loop;
  for I in 1 .. NThreads) loop
    accept continue; end loop;
end loop;
      Common barrier (cntd)
Each of the computational threads has the
  following form:

for I in 1 .. NumIterations loop
   … body of iteration …
end loop;
       Protected variables
Built-in mechanism for mutual exclusion
 and readers/writers on data.
      Concurrency in Java
• A thread is an object.
• Two ways to define a class of threads
  – extend class Thread and override run();
  – implement interface runnable and define
  interface runnable {
      public void run (); };
  Creating a thread by extending
class plum extends Thread {
   public void run() { … } }
plum P = new plum(); // creates thread P
P.start(); // starts P running.
• The start method is inherited from Thread
  and calls the “run” method.
• Alternatively, you can write
new Plum().start();
       Creating a thread by
     implementing Runnable
class Pear implements Runnable {
   public void run() { … }
Thread t1 = new Thread(new Pear());
new Thread (new Pear()).start();
 Pros and Cons of implementing
• Advantage: You can derive the new Thread
  class from a non-Thread class.
• Disadvantage: You cannot directly access
  Thread methods in the run method.
• But there is a workaround:
class of I implements Runnable {
  public void run {
    Thread t = Thread.currentThread();
     try { t.sleep(1000); }
     catch (InterruptedException ie) {return;} } }
    Example of non-interacting
Finding primality of N by dividing the
  range of potential factors into intervals
  and assigning each interval to a thread
    Mutual exclusion in Java
Static methods:
 static synchronized void IncrX(int I)
     { X = X+I; }
 Only one such method can run at a time.
Mutual exclusion on an object;
  static object XMutex = new object();
  synchronized(XMutex) { X = X+I; }
Static class members: 1 instance per class.
 Mutual exclusion over a method

Declaring a method “synchronized”
 means that calls to this method for a
 particular object of the class are
 mutually exclusive.
 Mutual exclusion over a method
class account {
   int Value = 0;
   synchronized void deposit(int D) {
      X = X+D; } }
account Fred, George;
Fred.deposit(10) and Fred.deposit(20) are
  mutually exclusive.
Fred.deposit(10) and George.deposit(20) are
       Wait/notify in Java
analogous to Ada rendezvous.

To top