Clone the following github repo for corresponding source code... http://github.com/preston/concurrency_using_threads/tree/master

1. Concurrency Using Threads
...with Preston Lee. Presentation and sample code
largely based on work by Jim Weirich.

2. TANSTAAFL
• http://www.gotw.ca/publications/concurrency-ddj.htm
• Published early 2005

6. Past Performance Gains
• Clock Speed
• Execution Optimization
• Cache

7. Use Cases
• Disk access • Application servers
• Network connections • Games
• Polling • Simulations
• Message queuing
• Scheduling
• Worker processing
• Long-polling

8. So, you want to write a
concurrent program ...

9. Demo: race1.rb

10. What happened?

11. The Setup
@amount += 1 @amount += 1
23

12. Step 1
@amount += 1 @amount += 1
23 1
23

13. Step 2
@amount += 1 @amount += 1
23 2 23
23

14. Step 3
@amount += 1 @amount += 1
24 23
3
24

15. Step 4
@amount += 1 @amount += 1
24 24
Should be 25
at this point! 24 4

16. Race Condition
@amount += 1 @amount += 1
23 1
2 23
3
24 4

17. Reordering Steps
@amount += 1 @amount += 1
24 1
3 25
2
25 4

18. Mutual Exclusion
Do These
@amount += 1 Together @amount += 1
24 1
3 25
2
25 4

19. DISABLE CONTEXT SWITCHING
account.credit(1)
RE-ENABLE CONTEXT SWITCHING

20. require ‘thread’
mutex = Mutex.new
...
mutex.synchonize do
account.credit(1)
end

21. Demo: race4.rb

22. Demo: race7.rb

23. To Be Safe, You Must:
(1) Protect every shared memory
access with a synchronizing lock.

24. To Be Safe, You Must:
(1) Protect every shared memory
access with a synchronizing lock.
Yes, EVERY access.

25. To Be Safe, You Must:
(2) Be aware of extended situations
that need to be atomic.

26. To Be Safe, You Must:
(3) Have a strategy to avoid
deadlock in the presence of
multiple locks.

27. To Be Safe, You Must:
(4) Evaluate every single library
used by your program to see if they
also follow rules 1 - 3.

28. Double Checked Lock
public static Singleton getInstance()
{
if (instance == null)
{
synchronized(Singleton.class) { //1
if (instance == null) //2
instance = new Singleton(); //3
}
}
return instance;
}
The theory behind double-checked locking is perfect.
Unfortunately, reality is entirely different.

29. Concurrent
Programming is
HARD

30. And it is hard because of
Shared
Memory

31. What can we do to
make concurrent
programming easier?

32. Avoid
Shared
Memory

33. Are We Blug
Programmers?
... Languages less powerful than Blub are obviously less
powerful, because they're missing some feature he's used to. But
when our hypothetical Blub programmer looks in the other
direction, up the power continuum, he doesn't realize he's looking
up. What he sees are merely weird languages... Blub is good
enough for him, because he thinks in Blub.
-- Paul Graham, Beating the Averages

34. Contact Info
• Preston Lee
• http://prestonlee.com
• http://openrain.com
• Twitter: @prestonism