2. About me
• Front-end developer
• Mobile developer
• Agile Coach / Mentor
• Currently working in Cengage

6. What is
Multithreading?
Multi-Threading is the ability of a CPU to execute several threads of execution apparently at the same
Multi-threading is a widespread programming and execution model that allows multiple threads to exist

7. Multi ~ threading /
tasking
• Multitasking is a method by which multiple processes share
common processing resources
• Multithreading extends the idea of multitasking into applications

8. Processes
8770 mdworker 0.0 00:00.11 4 0 54 75 6768K 5760K 0B 0B 104M 2467M 78770 195 sleeping
• A process is an instance of a program in execution
• Processes may be in one of five states: New, Ready, Running,
Waiting, Terminated

9. Threads
A thread is the smallest sequence of programmed instructions that can be managed independently by

10. Kind of Threads
• User level threads (you can play safely with them)
• Kernel level threads (less safely but still funny!)
• User level threads are in the scope of ActionScript and Flex

11. Threads and
Processes
• A thread is contained inside a process
• Multiple threads can exist within the same process and share
resources such as memory

12. Differences (1/2)
• A thread is light weight taking lesser resources than a process
• Process switching needs interaction with operating system while
thread switching does not
• Each process executes the same code using its own resources,
threads use same resources

13. Differences (2/2)
• While one thread is blocked and waiting, second thread in the
same task can run
• Multiple processes use more resources, multiple threaded
processes use fewer resources
• Processes operate independently of the others, threads access
other thread's data

14. Multithreading vs
Async
• Async is the better indicated for doing heavy IO bound
processing
• Multithreading is better indicated with long running processes

15. Trivial Parallelism
Scenario: large number of independent computation-intensive tasks
• Create a pool of threads and distribute the tasks into them
(accordingly to available CPUs)
• Create a master thread distribute the work and collect the
results

16. Performances
• An extra thread means more setup/teardown costs
• Implement multithreading only after having profiled your app
• Look for tasks with as few as possible dependencies

17. Parallel Algorithms
Algorithms that concurrently perform work on collections of data
Fibonacci(n):
1 if n < 2: | thread A
2 return n | thread A
3 x = spawn Fibonacci(n-1) | thread A
4 y = spawn Fibonacci(n-2) | thread B

18. Why Using
Multithreading
• To improve performances (quick and dirty answer!)
• To avoid that the GUI suffers of the latency of event driven
architecture

19. Responsiveness
• Keep heavy tasks outside the main thread is the traditional way
to keep the app responsive
• We actually lose overall performance due to the extra cost of
context switching
• But the user experience is anyway improved

21. Essentials
• Multithreading require carefully programming
• Manage the queue of requests
• Coordinating the work of multiple threads
• Don't access the UI from a not UI thread
• Try to avoid calling out to external code while holding a lock

22. Mutual Exclusion
• Sometimes we want things to happen simultaneously, and
sometimes not
• Reasoning about concurrent computation is mostly reasoning
about time
• Acquire and release shared members in order to grant access to
one thread per time

23. Implementing
Mutex
• Each critical section is associated with a unique Lock object
• The access to the section is locked and unlocked when trying to
enter the critical section

24. Concurrent Objects
• When more than one thread work together we are dealing with
threads pools
• When working with threads pools each thread should be paused
and resumed
• Managing concurrency it's possible to avoid blocking threads
slow down the exectuin time

25. Handle Race
Conditions
• Is when two threads access the same location in memory at the
same time (writing!)
• A race condition is a kind of bug, that happens only with certain

26. Avoid Deadlocks
A deadlock occurs when the waiting process is still holding on to another resource that the first needs
• Reduces the number of threads (keep things simple!)
• Don't hold several locks at once
• Don't execute foreign code while holding a lock

28. Before Flash Player
11.3
While the underlying Flash Player and Operating System use threads, the execution model for Actions

29. UI Blocking
if(appUI.isSlow){ app.quality === 'shitty app' }
• User interface not responsive
• The expected frame rate drops significantly
• The user experience was dramatically impacted

30. LocalConnection
Trick
• Load separate SWF in the page
• Handle communication through the LocalConnection class

31. Pseudo Threading
• Involves ENTER_FRAME, getTimer() and some calculation
• Not always reliable due to the getTimer() reliability
• Not simple to maintain

32. Asynchronous
Execution

33. Workers, the Holy
Grail!
• Complete separate SWF
• Independent DisplayList

35. The Worker Class
• A Worker instance is a virtual instance of the Flash / AIR runtime
• Each Worker controls and provides access to the lifecycle and
data of a single worker
• A worker is just another SWF that’s running alongside your main
SWF

36. Worker Support
if(Worker.isSupported){
}
• Desktop (Flash Player + AIR)
• Mobile (AIR on Android only, weird ?!?)

37. Create a Worker
WorkerDomain.current.createWorker(workerBytes);
The workerBytes variable contains the ByteArray of an SWF, include
it:
• Using the [Embed] metatag to embed the .swf file in the app

38. Isolation
• Workers do not have access to the same memory, variables, and
code
• Workers run in separated Flash Player instances
• What is shared between workers is under your control

39. Shared Properties
setSharedProperty(key:String, value:*):void
• Each worker can expose a set of properties to other workers
• Each worker can get the value stored in a shared property (from
another worker)
• Values are NOT passed by reference (AMF serialization)

40. Referenced Data
Types
• Worker
• MessageChannel

41. MessageChannel
while ( mainToBack.messageAvailable ){
mainToBack.receive();
}
• Send one-way messages and data from one worker to another
• Treats messages and related values as a queue

42. Shared Memory
• A Shareable ByteArray
• To pass around a reference to your shared memory, you use the
MessageChannel API
• When you pass a ByteArray, it is not serialized, just referenced
• You can then pass anything you want between the workers (as
raw binary data)

43. Mutex
var mutex:Mutex = new Mutex();
• Locks a particular block of memory or shared resource
• A Mutex manages access using the concept of resource
ownership

44. Condition
var condition:Condition = Condition(mutex);
condition.wait(timeout:Number = -1);
• Suspend the execution of a worker (i.e. thread)
• Resume the worker execution unlocking the associated mutex

46. Terminology
• Promise, is an object with a then method; it can have 3 states:
pending, fulfilled, or rejected
• Thenable is an object that defines a then method
• Reason is a value that indicates why a promise was rejected.

47. A promise
A promise represents the eventual result of an asynchronous operation
The point of promises is to give us back functional composition and error bubbling in the async world

48. Then
A promise's then method accepts two arguments and return a
promise
promise.then(onFulfilled, onRejected);

49. Deferred
A deferred object can do the same as a promise object, but it has two functions to trigger the done() a

50. Promises vs
Deferred
• The promise object does not have resolve() or reject() functions
• A promise is something shared w/ other objects, while a deferred
should be kept private

51. Resolvers
• Are used internally by Deferreds to create, resolve and reject
Promises
• Resolvers can propagate fulfillment and rejection

54. Q&A

55. Thanks
Grazie! Graçias! Danke! Merci! !