02 - Concurrency and - or in - Networking

Concurrency and
Networking
(or, in…)
From the Internet to the IoT - The Fundamentals of Modern

Computer Networking
ÉCOLE POLYTECHNIQUE –
CONCURRENCY AND  
(OR, IN...) NETWORKING
TODAY’S OBJECTIVES
‣ Recall the essence of last weeks lecture.
‣ Understand concurrency
‣ Principles
‣ Primitives
‣ And, how it works in Java
‣ Experiment two common “concurrent architectures” when writing

communicating programs
École Polytechnique • INF557: From the Internet to the IoT • The Fundamentals of Modern Computer Networking !57
CONCURRENCY AND  
AGENDA
‣ The Essence of Last Week: 
Identifiers, naming: layers, multiplexing, and demultiplexing
‣ Concurrency - the principle
‣ Concurrency - the primitives 
(Threads, Thread States, Barrier Synchronisation, Mutex, condition variables)
‣ (Some) Threaded Architectures
École Polytechnique • INF557: Fromthomas@thomasclausen.org

the Internet to the IoT • The Fundamentals of Modern Computer Networking !58
http://www.thomasclausen.org
CONCURRENCY AND  
QUESTION (THE ESSENCE OF LAST WEEK)

‣ What was the purpose of a name/an identifier?
‣ What does http://www.example.com.:80/path/filename.html tell us?
CONCURRENCY AND  

192.168.23.45
CONCURRENCY AND  

192.168.23.45
The
Big Bad
Internet
CONCURRENCY AND  

192.168.23.45
The
Big Bad
Internet
CONCURRENCY AND  

192.168.23.45
The IPv6 IPv4
Big Bad
Internet
CONCURRENCY AND  

192.168.23.45
The IPv6 IPv4
Big Bad
Internet Ethertype
CONCURRENCY AND  

192.168.23.45
… TCP UDP. …
The IPv6 IPv4
Big Bad
Internet Ethertype
CONCURRENCY AND  

192.168.23.45
… TCP UDP. …
The IPv6 IPv4 Protocol Number

ICMP=1, TCP=6, UDP=17 ......
Big Bad
Internet Ethertype
CONCURRENCY AND  

192.168.23.45
… IMAP HTTP SMTP IRC …
… TCP UDP. …

ICMP=1, TCP=6, UDP=17 ......
Big Bad
Internet Ethertype
CONCURRENCY AND  

192.168.23.45
… TCP UDP. … Port Number

IMAP=143, HTTP=80, SMTP=25 ......
ICMP=1, TCP=6, UDP=17 ......
Big Bad
Internet Ethertype
CONCURRENCY AND  

192.168.23.45
something.asp
script.cgi test.php filename.html

IMAP=143, HTTP=80, SMTP=25 ......
ICMP=1, TCP=6, UDP=17 ......
Big Bad
Internet Ethertype
CONCURRENCY AND  

192.168.23.45
something.asp
App specific
e.g. filenames, usernames, …
IMAP=143, HTTP=80, SMTP=25 ......
ICMP=1, TCP=6, UDP=17 ......
Big Bad
Internet Ethertype
CONCURRENCY AND  

192.168.23.45
something.asp
App specific
e.g. filenames, usernames, …
IMAP=143, HTTP=80, SMTP=25 ......
ICMP=1, TCP=6, UDP=17 ......
Big Bad
Internet Ethertype
To identify, unambiguously, one single resource on the Internet

CONCURRENCY AND  

The need to do this (identify, reach, ressources) efficiently remains a major design
challenge 
(e.g., remains largely unresolved in IoT, or even in the Internet as per NAPT)
CONCURRENCY AND  

something.asp
test.php
script.cgi filename.html
… TCP UDP. …
Network
challenge 
CONCURRENCY AND  

• We usually stop before “application specific” 
demultiplexing, when talking about Internet protocols 
and “identify a single process on the Internet” as:  … IMAP HTTP SMTP IRC …
… TCP UDP. …
• IP Address (implies IPv4/IPv6)
• Protocol number Network
• Port number
challenge 
CONCURRENCY AND  

• We usually stop before “application specific” 
demultiplexing, when talking about Internet protocols 
and “identify a single process on the Internet” as:  … IMAP HTTP SMTP IRC …
… TCP UDP. …
• IP Address (implies IPv4/IPv6)
• Protocol number Network
• Port number
CONCURRENCY AND  
AGENDA

CONCURRENCY AND  
CONCURRENCY AND  
CONCURRENCY AND  
CONCURRENCY AND  
CONCURRENCY AND  
Buy A Buy C
Sell A Sell D
Sell A Sell D
Sell B Buy C
Sell B Sell D
Sell B Buy C
CONCURRENCY AND  
Buy A Buy C
Sell A Sell D
Sell A Sell D
Sell B Buy C
Sell B Sell D
Sell B Buy C
Each trader:
‣ Sequentially executes buy/sell actions
‣ Independently executes these actions
‣ Is part of the same [stock exchange] system
CONCURRENCY AND  
Buy A Buy C
Sell A Sell D
Sell A Sell D
Sell B Buy C
Sell B Sell D
Sell B Buy C
Each trader:
‣ May execute his/her actions at the same time
CONCURRENCY AND  
Buy A Buy C
Sell A Sell D
Sell A Sell D
Sell B Buy C
Sell B Sell D
Sell B Buy C
CONCURRENCY AND  
Buy A Buy C
Sell A Sell D
Sell A Sell D
Sell B Buy C
Sell B Sell D
Sell B Buy C
Stock Exchange System:

‣ State depends on the sum of the actions of 
each trader
?
CONCURRENCY AND  
Buy A Buy C
Sell A Sell D
Sell A Sell D
Sell B Buy C
Sell B Sell D
Sell B Buy C

each trader
‣ And, on the?order in which they are executed
CONCURRENCY AND  
Buy A Buy C
Sell A Sell D
Sell A Sell D
Sell B Buy C
Sell B Sell D
Sell B Buy C
Each trader:
CONCURRENCY AND  
Buy A Buy C
Sell A Sell D
Sell A Sell D
Sell B Buy C
Sell B Sell D
Sell B Buy C
Each trader:
CONCURRENCY AND  
Buy A Buy C
Sell A Sell D
Sell A Sell D
Sell B Buy C
Sell B Sell D
Sell B Buy C
Each trader:
CONCURRENCY AND  
Buy A Buy C
Sell A Sell D
Sell A Sell D
Sell B Buy C
Sell B Sell D
Sell B Buy C
Each trader:
CONCURRENCY AND  
1. Buy A 1. Buy C
2. Sell A 2. Sell D
3. Sell A 3. Sell D
4. Sell B 4. Buy C
5. Sell B 5. Sell D
6. Sell B 6. Buy C
Each trader:
CONCURRENCY AND  
1. Buy A 1. Buy C
2. Sell A 2. Sell D
3. Sell A 3. Sell D
4. Sell B 4. Buy C
5. Sell B 5. Sell D
6. Sell B 6. Buy C
Each trader:
CONCURRENCY AND  
1. Buy A 1. Buy C
2. Sell D
2. Sell A 3. Sell D
3. Sell A 4. Buy C
5. Sell D
4. Sell B
5. Sell B 6. Buy C
6. Sell B
Each trader:
CONCURRENCY AND  
1. Buy A 1. Buy C
Coffee 2. Sell D
2. Sell A 3. Sell D
3. Sell A 4. Buy C
Buy Porche 5. Sell D
4. Sell B
Call mom
5. Sell B 6. Buy C
6. Sell B
Move bonus to tax-
Each trader: paradise
CONCURRENCY AND  
1. Buy A 1. Buy C
2. Coffee 2. Sell D
3. Sell A 3. Sell D
4. Sell A 4. Buy C
5. Buy Porche 5. Sell D
6. Sell B
6. Call mom
7. Sell B 7. Buy C
8. Sell B
8. Move bonus to tax- 
CONCURRENCY AND  
1. Buy A 1. Buy C
2. Coffee 2. Sell D
3. Sell A 3. Sell D
4. Sell A 4. Buy C
6. Sell B
6. Call mom
7. Sell B 7. Buy C
8. Sell B
CONCURRENCY AND  
1. Buy A 1. Buy C
2. Coffee 2. Sell D
3. Sell A 3. Sell D
4. Sell A 4. Buy C
6. Sell B
6. Call mom
7. Sell B 7. Buy C
8. Sell B
‣ Possibly interleaved by other internal actions
CONCURRENCY AND  
1. Buy A 1. Buy C
2. Coffee 2. Sell D
3. Sell A 3. Sell D
4. Sell A 4. Buy C
6. Sell B
6. Call mom
7. Sell B 7. Buy C
8. Sell B
CONCURRENCY AND  
1. Buy A 1. Buy C
2. Coffee 2. Sell D
3. Sell A 3. Sell D
4. Sell A 4. Buy C
6. Sell B
6. Call mom
7. Sell B 7. Buy C
8. Sell B
‣ Trivially maintain local ordering of own actions
CONCURRENCY AND  
1. Buy A 1. Buy C
2. Coffee 2. Sell D
3. Sell A 3. Sell D
4. Sell A 4. Buy C
6. Sell B
6. Call mom
7. Sell B 7. Buy C
8. Sell B
‣ Trivially maintain local ordering of own actions
CONCURRENCY AND  
Buy A Buy A Buy A

Buy A Buy A Buy A
Buy A Buy A Buy A
Sell A
CONCURRENCY AND  
Buy A Buy A Buy A

Buy A Buy A Buy A
Buy A Buy A Buy A
Sell A
CONCURRENCY AND  
Buy A
Buy A
Buy A
Buy A
Buy A
Buy A
Buy A
Buy A
Buy A
Sell A
CONCURRENCY AND  
Buy A
Buy A
Buy A
Buy A
Buy A
Buy A
Buy A
Buy A
Buy A
Sell A
CONCURRENCY AND  
Buy A
Buy A
Buy A
Buy A
Buy A
Buy A
Buy A
Buy A
Buy A
Sell A
CONCURRENCY AND  
Buy A
Buy A
Buy A
Sell A
Buy A
Buy A
Buy A
Buy A
Buy A
École Polytechnique • INF557: From the Internet to the IoT • The Fundamentals of Modern Computer Networking Buy A !74
CONCURRENCY AND  
Buy A
Buy A
Buy A
Sell A
Buy A
Buy A
Buy A
Buy A
Buy A
CONCURRENCY AND  
Buy A
Buy A
Buy A
Sell A
Buy A
Buy A
Buy A
Buy A
Buy A
CONCURRENCY AND  
Buy A Buy A Buy A

Buy A Buy A Buy A
Buy A Buy A Buy A
Sell A
CONCURRENCY AND  
Buy A Buy A Buy A

Buy A Buy A Buy A
Buy A Buy A Buy A
Sell A

each trader
‣ And, on the order in which they are executed
CONCURRENCY AND  
Buy A Buy A Buy A

Buy A Buy A Buy A
Buy A Buy A Buy A
Sell A

each trader
Each trader:
‣ State - causality with relevant actions of other traders
CONCURRENCY AND  
RECAPITULATING.....
Each trader:

each trader
CONCURRENCY AND  
RECAPITULATING.....
Each trader:

each trader
CONCURRENCY AND  
RECAPITULATING.....
Each trader:

each trader
CONCURRENCY AND  
AGENDA

Trader CONCURRENCY AND  
Sell A
Sequential
actions
Executed in
Buy car specified
order
Buy B
Trader CONCURRENCY AND  
Sell A
Sequential
actions
Executed in
Buy car specified
order
Buy B
Trader Thread CONCURRENCY AND  
Sell A send (a)

Sequential
actions
Executed in
Buy car specified a=b!
order
Buy B recv (b)
ThreadCONCURRENCY AND  
class Test{
public static String foo(){ send (a)

}
return “Foo”;
Sequential
actions
public static String bar(){
return “Bar”;
}
}
Executed in
specified a=b!
order
class Main{
public static void main(String[] args){
System.out.println(Test.foo()+” “+
Test.bar() );
}
recv (b)
}
CONCURRENCY AND  
Program
Address Space
Variables
Objects
foo()
bar()
Functions
CONCURRENCY AND  
Program
Address Space
Variables
Objects
foo()
bar()
Functions
CONCURRENCY AND  
Each Thread: Sequential

class Test{
actions
public static String foo(){
return “Foo”; Executed in
} specified
order
public static String bar(){
return “Bar”;
}
}
class Main{
CreateThreadMagic( Test.foo()+” “+ Test.bar() )
CreateThreadMagic( Test.bar()+” “+ Test.foo() )
StartBothThreads()
}
Obviously, Pseudocode
CONCURRENCY AND  
Program
Address Space
Variables
Objects
foo()
bar()
Functions
CONCURRENCY AND  
Program
Address Space
Variables
Objects
foo()
bar()
Functions
CONCURRENCY AND  
Shared Address Space
CONCURRENCY AND  
Scheduling
CONCURRENCY AND  
Scheduling
CONCURRENCY AND  
Scheduling
CONCURRENCY AND  
Scheduling
or
CONCURRENCY AND  
Scheduling
or or
CONCURRENCY AND  
Scheduling
or or or or
CONCURRENCY AND  
Scheduling
or or or or or
CONCURRENCY AND  
Scheduling
A Thread:
An list of tasks, to be executed in sequential order.
A CPU:
or or A collection of 1-n execution units, eachor or tasks
executing orperfectly
sequentially
Scheduling:
Mapping of tasks from threads onto execution units
Observation:
Cannot assume order of execution of tasks to be known or even
deterministic.
CONCURRENCY AND  
A Thread:
New CONCURRENCY AND  
A Thread:
A Thread:
Runnable
Not waiting for ressources
Not waiting for something to happen in other threads
Can be scheduled for execution…
…but may or may not be actually running  
(e.g. it may not right now be mapped onto an
execution unit)
A Thread:
Runnable
execution unit)
Not Runnable
Waiting for ressources
Waiting for some specific time to pass
Can not be scheduled for execution…
A Thread:
Runnable
execution unit)
Not Runnable
A Thread:
Runnable Dead
execution unit)
Not Runnable
CONCURRENCY AND  
PRIMITIVE:
THREAD AND THREAD STATES
Thread t = new Thread (…)
t.start()
t.run()
New
A Thread: CONCURRENCY AND  
An list of tasks, to be executed in sequential order. (OR, IN...) NETWORKING
Runnable Dead
Not Runnable
New
Thread t = new Thread (...) CONCURRENCY AND  
New
CONCURRENCY AND  
Thread t = new Thread (...) (OR, IN...) NETWORKING
t.start()
Runnable
New
CONCURRENCY AND  
t.start()
t.run() exits...
Runnable Dead
New
CONCURRENCY AND  
t.start()
t.run() exits...
Runnable Dead
Scheduler
Ready yield() Running
New
CONCURRENCY AND  
t.start()
t.run() exits...
Runnable Dead
Scheduler
Not Runnable
École Polytechnique • INF557: From the Internet to the IoT • The Fundamentals of Modern Computer Networking 93
New
CONCURRENCY AND  
t.start()
t.run() exits...
Runnable Dead
Scheduler
sleep(timeout)
wait(timeout)
Not Runnable join(timeout)
wait()
join()
“Synchronization”
New
CONCURRENCY AND  
t.start()
t.run() exits...
Runnable Dead
Scheduler
sleep(timeout)
wait(timeout)
Not Runnable join(timeout)
Block wait()
join()
Timed “Synchronization”
Wait
Wait
New
Thread t = new Thread (...) CONCURRENCY AND  
t.start()
t.run() exits...
Runnable Dead
Scheduler
timeout expiration
join() returns
Not Runnable
Block notify() received
“Synchronization”
Timed
Wait
Wait
CONCURRENCY AND  
CREATE, START, RUN THREADS - JAVA

class ThreadFromRunnable implements Runnable{
String s;
public ThreadFromRunnable(String t){
s = t;
}
public void run(){
while (true){ System.out.print(s); }
}
}
class RunnableExample{

Thread t1 = new Thread(new ThreadFromRunnable("a"));
Thread t2 = new Thread(new ThreadFromRunnable("b"));
t1.start();
t2.start();
}
}
CONCURRENCY AND  
PRIMITIVE:
BARRIER SYNCHRONISATION
s.join()
CONCURRENCY AND  
Runnable Dead Dead Runnable
t s
Not Runnable Not Runnable
Waiting Waiting
CONCURRENCY AND  
t s
Waiting Waiting
CONCURRENCY AND  
t s
Waiting Waiting
CONCURRENCY AND  
t s
Waiting Waiting
s.join()
CONCURRENCY AND  
t s
Waiting Waiting
s.join()
CONCURRENCY AND  
t s
Waiting Waiting
s.join()
CONCURRENCY AND  
t s
Waiting Waiting
s.join() s.run()
! exits
CONCURRENCY AND  
t s
Waiting Waiting
s.join() s.run()
exits
CONCURRENCY AND  
t s
Waiting Waiting
s.join() s.run()
exits
CONCURRENCY AND  
t s
Waiting Waiting
s.join() s.run()
exits
Primitive:
“barrier synchronization”
CONCURRENCY AND  
BARRIER SYNCHRONIZATION - JAVA

import java.lang.Thread;
class BarrierSync implements Runnable{
String s; Thread joinWith; int count;
public BarrierSync(String t, Thread jw, int c){
s = t; joinWith = jw ; count = c;
}
public void run(){
for (int i=0 ; i< count ; i++) {System.out.print(s);}
if (joinWith !=null){
try{ joinWith.join(); }
catch (InterruptedException e){}
System.out.println("\nAll Done");
}
}
}
class BarrierSyncSimple{
Thread t1 = new Thread(new BarrierSync("a", null, 1000));
Thread t2 = new Thread(new BarrierSync("b", t1, 10));
t1.start(); t2.start();
}
}
CONCURRENCY AND  
PRIMITIVE:
MUTUAL EXCLUSION (MUTEX)
synchronised {…}

CONCURRENCY AND  
Thread A: Thread B:
.... ....
public void run(){ public void run(){
x = 42 x = 0
a = x+24 b = x+24
b.join() }
print (“A: “+a)
print (“B: “+b)
}
CONCURRENCY AND  
Thread A: Thread B:
.... ....
x = 42 x = 0
a = x+24 b = x+24
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66
B: 24
x = 42 x = 0
a = x+24 b = x+24
x = 0 x = 42
b = x+24 a = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
x = 42 x = 0
a = x+24 b = x+24
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66
B: 24 B: 66
x = 42 x = 0 x = 0
a = x+24 b = x+24 x = 42
x = 0 x = 42 a = x+24
b = x+24 a = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
x = 42 x = 0
a = x+24 b = x+24
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
x = 0 x = 42 a = x+24 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
x = 42 x = 0
a = x+24 b = x+24
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
x = 0 x = 42 a = x+24 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
A: 66
B: 24
x = 42 x = 0
a = x+24 b = x+24
x = 0 x = 42
b = x+24 a = x+24
A: 66 A: 24
B: 66 B: 24
x = 0 x = 42
x = 42 x = 0
a = x+24 a = x+24
b = x+24 b = x+24
CONCURRENCY AND  
A: 66 “Race Condition”
B: 24 Result of execution may not be deterministic when one
(or more) variable(s) is shared between two or more
threads AND at least one of the threads modifies said
x = 42 x = 0 variable(s).
a = x+24 b = x+24
x = 0 x = 42
b = x+24 a = x+24
A: 66 A: 24
B: 66 B: 24
x = 0 x = 42
x = 42 x = 0
a = x+24 a = x+24
b = x+24 b = x+24
CONCURRENCY AND  
a = x+24 b = x+24
x = 0 x = 42
b = x+24 a = x+24
“Critical Section”
A: 66 A: 24 A set of instructions, accessing one (or more) shared
B: 66 B: 24 variable(s), whose execution should be rendered
indivisible [in order to ensure that the performed
computations produce a deterministic result].
x = 0 x = 42
x = 42 x = 0
a = x+24 a = x+24
b = x+24 b = x+24
CONCURRENCY AND  
a = x+24 b = x+24
x = 0 x = 42
b = x+24 a = x+24
A: 66 A: 24 A set of instructions, accessing one (or more) shared
B: 66 B: 24 variable(s), whose execution should be rendered
x = 0 x = 42
x = 42 x = 0
a = x+24 a = x+24
b = x+24 b = x+24 “Synchronisation”
The act of ensuring the order of execution so as that
the performed computations produce a deterministic
result.
CONCURRENCY AND  
a = x+24 b = x+24
x = 0 x = 42
b = x+24 a = x+24
A set of instructions, accessing one (or more) shared
variable(s), whose execution should be rendered
“Synchronisation”
result.
CONCURRENCY AND  
A: 66
B: 24
x = 42 x = 0
a = x+24 b = x+24
x = 0 x = 42
b = x+24 a = x+24
CONCURRENCY AND  
a = x+24 b = x+24
x = 0 x = 42
b = x+24 a = x+24
CONCURRENCY AND  
a = x+24 b = x+24
x = 0 x = 42
b = x+24 a = x+24
CONCURRENCY AND  
a = x+24 b = x+24
x = 0 x = 42
b = x+24 a = x+24
“Synchronisation”
result.
CONCURRENCY AND  
Thread A: Thread B:
.... ....
x = 42 x = 0
a = x+24 b = x+24
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
x = 0 x = 42 a = x+24 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
x = 42 x = 0
a = x+24 b = x+24
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
École Polytechnique x = 0 From the xInternet
• INF557: = 42 a = x+24
to the IoT • The Fundamentals of Modern Computer Networking a = x+24 !112
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
x = 42 x = 0
a = x+24 b = x+24
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
• INF557: = 42 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
boolean lock = false
x = 42 x = 0
a = x+24 b = x+24
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
• INF557: = 42 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
x = 42 x = 0
a = x+24 b = x+24
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
• INF557: = 42 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
if (!lock){ if (!lock){
lock = true; lock = true;
x = 42 x = 0
a = x+24 b = x+24
lock = false lock = false
} }
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
• INF557: = 42 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
x = 42 x = 0
a = x+24 b = x+24
}
?
}
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
• INF557: = 42 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
x = 42 x = 0
a = x+24 b = x+24
}
?
}
b.join() }
print (“A: “+a) A: 66
print (“B: “+b) B:
}
A:
B: 24
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
• INF557: = 42 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
x = 42 x = 0
a = x+24 b = x+24
?
b.join() }
print (“A: “+a) A: 66
}
A:
B: 24
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
• INF557: = 42 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
while (!lock){} while (!lock){}
x = 42 x = 0
a = x+24 b = x+24
?
b.join() }
print (“A: “+a) A: 66
}
A:
B: 24
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
• INF557: = 42 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
x = 42 x = 0
a = x+24 b = x+24
?
b.join() }
print (“A: “+a) A: 66
}
A:
B: 24
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
• INF557: = 42 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  

Didn’t solve the problem
Just introduced an additional critical region …
CONCURRENCY AND  

Didn’t solve the problem
Just introduced an additional critical region …
… if this was a concurrency “theory” course, we would first  

introduce the notion of a “spinlock” here …
… but, as this is “concurrency for networking”,  

we’ll go straight to the goal …
… and introduce the notion of a MUTEX, and its Java instantiation, directly.
CONCURRENCY AND  
Thread A: Thread B:
.... ....
x = 42 x = 0
a = x+24 b = x+24
?
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
• INF557: = 42 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Btw this is NOT actual Java (OR, IN...) NETWORKING
Thread A: Thread B:
.... ....
Mutex lock = false
lock = true; Special Property of Mutex: lock = true;
x = 42 For any given Mutex, one and only one thread will x = 0
a = x+24 be able to execute take() and release(), at any given b = x+24
lock = false time I.e., no “both read true at the same time” lock = false
problem.
?
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
• INF557: = 42 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
Mutex lock = false
lock.take() lock.take()
Special Property of Mutex:
lock.release() time I.e., no “both read true at the same time” lock.release()
problem.
?
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
• INF557: = 42 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
Mutex lock = false
problem.
?
b.join() }
print (“A: “+a)
print (“B: “+b)
}
A: 66 A: 66 A: 24
B: 24 B: 66 B: 24
x = 42 x = 0 x = 0 x = 42
a = x+24 b = x+24 x = 42 x = 0
• INF557: = 42 a = x+24
b = x+24 a = x+24 b = x+24 b = x+24
CONCURRENCY AND  
Thread A: Thread B:
.... ....
Mutex lock = false
problem.
b.join() }
print (“A: “+a)
print (“B: “+b)
}
École Polytechnique • INF557: From the Internet to the IoT • The Fundamentals of Modern Computer Networking
CONCURRENCY AND  
Thread A: Thread B:
.... ....
Mutex lock = false
problem.
b.join() }
print (“A: “+a) Only one thread executes
print (“B: “+b)
}
critical region at a time
Mutual Exclusion (MUTEX)
Mechanism for ensuring proper
order-of-execution of instructions
Obviously:
Critical Regions must be identified
And, protected by take()/release()
CONCURRENCY AND  
Th Val
Thread A: import java.lang.Thread; (b
ut is id,
.... class ThreadA extends Thread{ ab is, bu
,w
& e in
us ho t..
illu cl
str ud
public void run(){ Thread joinWith; ate ed
lock.take() public aThread (Thread t){ ing we
s “ it a
cla s it
Ja ver
joinWith = t; ss sh
ic ow
x = 42 } MU s
a = x+24 va ,  TE pre
Xe cis
s” el
lock.release()
b.join()
public void run(){
synchronized(MT.mutex){ MT.x = 42; MT.a = MT.x+24;}
  ak y th
in
to e pr
in evi
pt ou
print (“A: “+a) try{ joinWith.join(); } catch (InterruptedException e){} hr s
ea sl
System.out.println("A: "+MT.a); ds ide
print (“B: “+b) ) s 
System.out.println("B: "+MT.b);
} }
}
Thread B:
class ThreadB extends Thread{
.... public void run(){
public void run(){ synchronized(MT.mutex){ MT.x = 0; MT.b = MT.x+24;}
}
lock.take() }
x = 0
b = x+24 class MT{
lock.release() static int x, a, b; static Object mutex = new Object();
} public static void main(String[] args){
Thread t1 = new Thread(new ThreadB());
Thread t2 = new Thread(new ThreadA(t1));
}
}
ARCHITECTURE,
PROTOCOLS & THE
APPLICATION LAYER
CONCURRENCY LEADS TO THREADS, THREADS LEAD TO

MUTEXES...AND MUTEXES LEAD TO…SUFFFFFFFERING….?
Object s = new Object()
Object t = new Object()
ARCHITECTURE,
PROTOCOLS & THE
APPLICATION LAYER

synchronized(s){ synchronized(t){
ARCHITECTURE,
PROTOCOLS & THE
APPLICATION LAYER

synchronized(t){ synchronized(s){
ARCHITECTURE,
PROTOCOLS & THE
APPLICATION LAYER

Deadlock! synchronized(t){ synchronized(s){
ARCHITECTURE,
PROTOCOLS & THE
APPLICATION LAYER

ARCHITECTURE,
PROTOCOLS & THE
APPLICATION LAYER

} // releases t } // releases s
} // releases s } // release t
ARCHITECTURE,
PROTOCOLS & THE
APPLICATION LAYER


Executed
Never
} // releases t } // releases s
} // releases s } // release t
CONCURRENCY AND  
Th Val
Thread A: import java.lang.Thread; (b
ut is id,
.... class ThreadA extends Thread{ ab is, bu
,w
& e in
us ho t..
illu cl
str ud
public void run(){ Thread joinWith; ate ed
lock.take() public aThread (Thread t){ ing we
s “ it a
cla s it
Ja ver
joinWith = t; ss sh
ic ow
x = 42 } MU s
a = x+24 va ,  TE pre
Xe cis
s” el
lock.release()
b.join()
public void run(){
synchronized(MT.mutex){ MT.x = 42; MT.a = MT.x+24;}
  ak y th
in
to e pr
in evi
pt ou
print (“A: “+a) try{ joinWith.join(); } catch (InterruptedException e){} hr s
ea sl
print (“B: “+b) ) s 
} }
}
Thread B:
.... public void run(){
public void run(){ synchronized(MT.mutex){ MT.x = 0; MT.b = MT.x+24;}
}
lock.take() }
x = 0
b = x+24 class MT{
lock.release() static int x, a, b; static Object mutex = new Object();
} public static void main(String[] args){
}
}
CONCURRENCY AND  
Th Val
import java.lang.Thread; (b
ut is id,
class ThreadA extends Thread{
,w
& e in ab is, bu
us ho t..
illu cl
str ud
Thread joinWith; ate ed
public aThread (Thread t){
s “ it a
cla s it ing we
Ja ver
ss sh
joinWith = t; ic ow
MU s
} TE pre
Xe cisva , 
s” el
public void run(){  
ak y th
in
to e pr
synchronized(MT.mutex){ MT.x = 42; MT.a = MT.x+24;} in evi
pt ou
try{ joinWith.join(); } catch (InterruptedException e){} hr s
ea sl
) s 
}
}

public void run(){
synchronized(MT.mutex){ MT.x = 0; MT.b = MT.x+24;}
}
}
class MT{
static int x, a, b; static Object mutex = new Object();
}
}
CONCURRENCY AND  
Mutex / Condition
Variable/Semaphore
CONCURRENCY AND  
Mutex / Condition
Variable/Semaphore
Shared Variable
CONCURRENCY AND  
Mutex / Condition
Variable/Semaphore
Shared Variable
Critical Regions
CONCURRENCY AND  
Mutex / Condition
Variable/Semaphore
Shared Variable
Disjoint from
Critical Regions
CONCURRENCY AND  
Mutex / Condition Object Orientation

Variable/Semaphore
Shared Variable
Data
Disjoint from
Methods
Critical Regions
CONCURRENCY AND  
Monitor
mutex
Object
Condition Variable
CONCURRENCY AND  
Data accessible only by Monitor

method invocations (private…)
mutex
Object
Condition Variable
CONCURRENCY AND  

mutex
All method invocations:
• start by lock(mutex)
• end by unlock(mutex) Object
Condition Variable
CONCURRENCY AND  

mutex
At any point in time, at most one

threads “occupies” the monitor
Condition Variable
CONCURRENCY AND  

mutex
At any point in time, at most one

threads “occupies” the monitor
Condition variables implicitly and 
exclusively reference single mutex
Condition Variable
CONCURRENCY AND  

mutex
class ExampleOfMonitor{
private int mySharedValue;
public synchronized void set (int i){
mySharedValue=i;
}
public synchronized int get(){
return mySharedValue;
}
public synchronized void reset(){
mySharedValue=0;
} Condition Variable
}
CONCURRENCY AND  
PRIMITIVE:
CONDITION VARIABLES
wait()
notify()
notifyAll()

CONCURRENCY AND  
Queue
Producer Consumer
CONCURRENCY AND  
Queue
put(...) get()
Producer Consumer
CONCURRENCY AND  
Critical section
MUTEX?
Queue
put(...) get()
Producer Consumer
CONCURRENCY AND  
put(...) if queue full? Critical section

MUTEX?
Queue
put(...) get()
Producer Consumer
CONCURRENCY AND  

get(...) if queue empty? MUTEX?
Queue
put(...) get()
Producer Consumer
CONCURRENCY AND  

get(...) if queue empty? MUTEX?
Queue
put(...) get()
Producer Consumer
Not enough to protect against concurrent access ....
Btw this is NOT real Java CONCURRENCY AND  
Producer:
.... Mutex lock = new Mutex()
public void run(){ Critical section
lock.take()
queue.put(...)
lock.release()
}
Queue
put(...) get()
Producer Consumer
if queue is full? Block? Error ?

Producer:
lock.take()
if (!queue.full()){
queue.put(...)
}
lock.release() Queue
}
put(...) get()
Producer Consumer

Producer:
lock.take()
while (!queue.full()){
queue.put(...)
}
}
put(...) get()
Producer Consumer

Producer:
public void run(){ Queue will never be emptied, Critical section
lock.take() lock never released
while (!queue.full()){
queue.put(...)
}
}
put(...) get()
Producer Consumer

Producer:
lock.take()
while (queue.full()){
queueNotFull.wait(lock)
}
queue.put(...) Queue
lock.release()
}
put(...) get()
Producer Consumer

Producer:
public void run(){ “Temporarily” relinquish lock Critical section
lock.take() until a get() has happened?
queueNotFull.wait(lock)
}
queue.put(...) Queue
lock.release()
}
put(...) get()
Producer Consumer

Producer: Consumer:
.... Mutex lock = new Mutex() ....
while (queue.full()){ queue.get()
queueNotFull.wait(lock) queueNotFull.notify(lock)
} lock.release()
queue.put(...) }
lock.release()
}
Producer: Consumer:
} lock.release()
queue.put(...) }
lock.release()
}
What do we expect here?
Producer: Consumer:
} lock.release()
queue.put(...) }
lock.release()
}

‣ Relinquish lock on s
Producer: Consumer:
} lock.release()
queue.put(...) }
lock.release()
}

‣ Producer suspended
Producer: Consumer:
} lock.release()
queue.put(...) }
lock.release()
}

‣ Producer awakened when condition is
signalled satisfied
Producer: Consumer:
} lock.release()
queue.put(...) }
lock.release()
}

‣ Producer awakened when condition is
signalled satisfied
Solution: Condition Variable
Producer:
public void run(){
lock.take()
while (queue.full()){ class ConditionVariable{
queueNotFull.wait(lock) private Queue suspendedThreads = new Queue()
}
queue.put(...) public void wait(Mutex s){
// add calling thread to suspendedThreads
lock.release() s.unlock()
} // tell scheduler that thread is blocked
s.lock()
}
Consumer:
.... public void notify(){
Thread t = suspendedThreads.first();
public void run(){ // tell scheduler that t is unblocked
lock.take() }
queue.get()
queueNotFull.notify(lock)
lock.release()
}
Producer: Consumer:
....
} lock.release()
queue.put(...) }
lock.release()
}
Producer: Consumer:
....
queueNotFull.wait(lock)} queueNotFull.notify(lock)
queue.put(...) lock.release()
lock.release() }
}
Producer: Consumer:
....
queueNotFull.wait(lock)}
queue.put(...)
queue.get()
lock.release() queueNotFull.notify(lock)
} lock.release()
}
Producer: Consumer:
....
while (queue.full()){ while(queue.empty()){
queueNotFull.wait(lock)} queueNotEmpty.wait(s)
queue.put(...) }
queueNotEmpty.signal(s) queue.get()
} lock.release()
}
Producer: Consumer:
....
queue.put(...) }
} lock.release()
}
To Retain:
Producer: Consumer:
....
queue.put(...) }
} lock.release()
}
To Retain:
• Condition Variables associated with a lock
Producer: Consumer:
....
queue.put(...) }
} lock.release()
}
To Retain:
• Permit temporarily relinquishing lock - to be regained
Producer: Consumer:
....
queue.put(...) }
} lock.release()
}
To Retain:
• Must ensure that shared data is consistent !
Producer: Consumer:
....
queue.put(...) }
} lock.release()
}
To Retain:
• wait() instructs scheduler to ignore waiting thread
Producer: Consumer:
....
queue.put(...) }
} lock.release()
}
To Retain:
• wait() instructs scheduler to ignore waiting thread
• Note that notify() when no waiting threads are lost
Producer: Consumer:
....
queue.put(...) }
} lock.release()
}
To Retain: Te
no rm
ab rma ino
• Condition Variables associated with a lock ou lly l o
t “ , i gy
• Permit temporarily relinquishing lock - to be regained In
wa java
it/ , t
co t’s A
nd w le
iti ait rt:
on /s
• Must ensure that shared data is consistent ! no he
tif eq
y uiv
va ign
ria al
ble w h
• wait() instructs scheduler to ignore waiting thread ale
nt
s” e n
tal
• Note that notify() when no waiting threads are lost co
nc
ep
ts
kin
g
ar
ec
all
ed
CONCURRENCY AND  
CONDITION VARIABLES - A JAVA EXAMPLE
CONCURRENCY AND  

class PizzaPlace extends Thread{
House deliveryLocation;
public PizzaPlace(House h){
deliveryLocation = h;
}
public void run(){

deliveryLocation.deliverPizza();
}
class PizzaEater extends Thread{

House theHouse;
public PizzaEater(House h){
theHouse = h;
}
public void run(){

theHouse.eatPizza();
}
}
CONCURRENCY AND  

class PizzaPlace extends Thread{
public PizzaPlace(House h){
}
public void run(){

deliveryLocation.deliverPizza();
}
class PizzaEater extends Thread{

House theHouse;
public PizzaEater(House h){
theHouse = h;
}
public void run(){

theHouse.eatPizza();
}
}
class PizzaTest{
public static void main (String[] args) throws Exception{
House ThomasHouseFridayNight = new House();
Thread Thomas = new Thread(new PizzaEater(ThomasHouseFridayNight));
Thread PizzaHut = new Thread(new PizzaPlace(ThomasHouseFridayNight));
Thomas.start() ; PizzaHut.start();
}
}
CONCURRENCY AND  

class PizzaPlace extends Thread{ import java.lang.Thread;
public PizzaPlace(House h){ class House{
} private boolean pizzaAvailable = false;
public void run(){ public synchronized void eatPizza(){

deliveryLocation.deliverPizza(); while (!pizzaAvailable){
} System.out.println("Oh dear, no pizza,  
better call the Pizza Place!");
} try{ wait(); }  
catch (InterruptedException e){};
class PizzaEater extends Thread{ }
House theHouse; System.out.println("Woo-hoo, I'm eating pizza....");
public PizzaEater(House h){ }
theHouse = h; public synchronized void deliverPizza(){
} pizzaAvailable = true;
System.out.println("Pizza delivered!");
public void run(){ notify();
theHouse.eatPizza(); }
} }
}
class PizzaTest{
public static void main (String[] args) throws Exception{
House ThomasHouseFridayNight = new House();
Thread Thomas = new Thread(new PizzaEater(ThomasHouseFridayNight));
Thread PizzaHut = new Thread(new PizzaPlace(ThomasHouseFridayNight));
Thomas.start() ; PizzaHut.start();
}
}
CONCURRENCY AND  
AGENDA

ARCHITECTURE,
PROTOCOLS & THE
APPLICATION LAYER
WHY THREADS?
WHY CONCURRENT PROGRAMMING?
‣ Exploit multiple execution units 
(CPUs, cores)
‣ Software Engineering:
‣ Blocking System Calls 
e.g. java.io.InputStream.read()
‣ Modularity & Architecture
CONCURRENCY AND  
SOFTWARE ARCHITECTURE PIPELINING

Program
Stage 1 Stage 2 Stage n

Input Output
Files Files Files
Databases Databases Databases
Disks Disks Disks
Special Devices Special Devices Special Devices
CONCURRENCY AND  

Program

Input Output
CONCURRENCY AND  

Program

Input Output
CONCURRENCY AND  

Program

Input Output
“batch” of input for

similar processing
CONCURRENCY AND  

Program

Input Output
Specialised “single-task” stages

“batch” of input for Similar “processing time” / stage
similar processing Communication between stages?
CONCURRENCY AND  

Program

Input Output
cat /etc/shadow |
grep "werner" |
john - |
mailx -s "BW’s password" tout-le-monde-sur-site@polytechnique.fr
You may already know this concept

CONCURRENCY AND  
SOFTWARE ARCHITECTURE MASTER-WORKER

Program Worker 1
Files
Worker 2
Master Databases
Disks
Worker n
Special Devices
CONCURRENCY AND  

Worker 1
Program Worker 1
Files
Worker 2
Master Databases
Disks
Worker n
Special Devices
Request Dispatch
CONCURRENCY AND  

Program Worker 1
Files
Worker 2
Master Databases
Disks
Worker n
Special Devices
Request Dispatch
CONCURRENCY AND  

Identical
Program Worker 1
Files
Worker 2
Master Databases
Disks
Worker n
Special Devices
Request Dispatch Same

Resources !146
CONCURRENCY AND  
“Interfaces” by way of Synchronised Queue
Worker 1
Worker 2 Files
Master Databases
Disks
Worker n
Special Devices
CONCURRENCY AND  
Worker 1
Worker 2 Files
Master Databases
Disks
Worker n
Special Devices
CONCURRENCY AND  
Worker 1
Worker 2 Files
Master Databases
Disks
Worker n
Special Devices
CONCURRENCY AND  
LAB TODAY: XURL -> XCRAWLER

Worker 1
URL
URL
URL
…
Worker 2
Master
User Interaction 1. Get URL from queue
2. Check if already downloaded 
(if not, mark that it will be)
3. Download file on ORL

Worker n 4. Save to disk
5. If file is html, parse for URLs 
Add found URLs to the queue
CONCURRENCY AND  

Worker 1
URL
URL
URL
…
Worker 2
Master

CONCURRENCY AND  

Worker 1
URL
URL
URL
…
Worker 2
Master

Synchronized 
Queue of URLs to download
CONCURRENCY AND  

Synchronised 
List of URLs already downloaded, or
in the process of being downloaded
Worker 1
URL
URL
URL
…
Worker 2
Master

Synchronized 
Queue of URLs to download
CONCURRENCY AND  
TODAY’S KEY POINTS

‣ Applications inherently concurrent
‣ GUI updating while downloading, while GPS tracking, …
‣ Actually makes SW architecture design easier
‣ Requires care - synchronisation
‣ One approach: one thread per module + synchronised queues between modules
‣ Primitives
‣ Threads
‣ MUTEXes (synchronised …)
‣ Condition Variables (wait/notify)
‣ Monitors (Object w/ one mutex + one condition variable)
‣ Barrier Synchronisation (join)
‣ Architectures
‣ Pipelining
‣ Master-Worker
CONCURRENCY AND  
Off to the salt mines salles d’info....
https://www.polytechnique.edu/

02 - Concurrency and - or in - Networking

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

02 - Concurrency and - or in - Networking

Uploaded by

Copyright:

Available Formats

Concurrency and

From the Internet to the IoT - The Fundamentals of Modern

‣ Experiment two common “concurrent architectures” when writing

‣ (Some) Threaded Architectures

École Polytechnique • INF557: Fromthomas@thomasclausen.org

QUESTION (THE ESSENCE OF LAST WEEK)

QUESTION (THE ESSENCE OF LAST WEEK)

QUESTION (THE ESSENCE OF LAST WEEK)

QUESTION (THE ESSENCE OF LAST WEEK)

QUESTION (THE ESSENCE OF LAST WEEK)

The IPv6 IPv4

QUESTION (THE ESSENCE OF LAST WEEK)

The IPv6 IPv4

QUESTION (THE ESSENCE OF LAST WEEK)

The IPv6 IPv4

QUESTION (THE ESSENCE OF LAST WEEK)

The IPv6 IPv4 Protocol Number

QUESTION (THE ESSENCE OF LAST WEEK)

… IMAP HTTP SMTP IRC …

The IPv6 IPv4 Protocol Number

QUESTION (THE ESSENCE OF LAST WEEK)

… IMAP HTTP SMTP IRC …

… TCP UDP. … Port Number

QUESTION (THE ESSENCE OF LAST WEEK)

… TCP UDP. … Port Number

QUESTION (THE ESSENCE OF LAST WEEK)

QUESTION (THE ESSENCE OF LAST WEEK)

To identify, unambiguously, one single resource on the Internet

QUESTION (THE ESSENCE OF LAST WEEK)

QUESTION (THE ESSENCE OF LAST WEEK)

QUESTION (THE ESSENCE OF LAST WEEK)

QUESTION (THE ESSENCE OF LAST WEEK)

‣ (Some) Threaded Architectures

École Polytechnique • INF557: Fromthomas@thomasclausen.org

Stock Exchange System:

Stock Exchange System:

Buy A Buy A Buy A

Buy A Buy A Buy A

Buy A Buy A Buy A

Buy A Buy A Buy A

Stock Exchange System:

Buy A Buy A Buy A

Stock Exchange System:

Stock Exchange System:

Stock Exchange System:

Stock Exchange System:

‣ (Some) Threaded Architectures

École Polytechnique • INF557: Fromthomas@thomasclausen.org

Sell A send (a)

Buy B recv (b)

public static String foo(){ send (a)

Each Thread: Sequential

Shared Address Space

Can not be scheduled for execution…

Can not be scheduled for execution…

Can not be scheduled for execution…

CREATE, START, RUN THREADS - JAVA

public static void main(String[] args){

Runnable Dead Dead Runnable

Not Runnable Not Runnable

Runnable Dead Dead Runnable

Not Runnable Not Runnable

… if this was a concurrency “theory” course, we would first  

… but, as this is “concurrency for networking”,  