what every web and app developer should know about multithreading

1. what every web and app developershould know about multithreading

On the desktop, one core is rarely enough

On the web, sometimes we need parallel execution

Performance requires caching

Persistence of connectivity requires responsiveness

Disk and network I/O is indispensible and v eryslow

A way to execute two things at once

A way to execute two things almost at once

Lightweight

Independent execution

Almost like a separate process

A process is isolated in memory

When it dies, its memory is released

When it dies, its threads die too

Somewhat difficult to talk to other processes

All threads in a process share memory

Can be started and stopped as needed

On some platforms, cheaper to launch than a process

Can be native (kernel-based) or user-mode

Less predictable execution

Must control for re-entrancy of code

Must be aware of shared data

More difficult than it seems

We must retain predictability in our programs

Two threads fighting for the same variable

If we started out with x = 2, we end up with x = 5

First rule of synchronization:avoid needing it

Thread-local storage

Function scope variables

No side effects

Functional languages

First rule of synchronization:avoid needing it

Thread-local storage

Function scope variables

No side effects

Functional languages

Second rule of synchronization:join threads

Use a worker thread

Join wait for it to finish, then read its results

Third rule of synchronization:go critical

Declare a critical section

You are alone within your application

until you end the critical section

Application-wide setting

Hard to use when you have a bunch of threads

Third rule of synchronization:mutual exclusion

Third rule of synchronization:mut ualex clusion

Third rule of synchronization:mutex

Allows you to lock and unlock resources

Like an object for a mini-critical section

Thread A

lock M

my_local_x = x

set x = my_local_x + 1

unlock M

Thread B

lock M

my_local_x = x

set x = my_local_x + 1

unlock M

Third rule of synchronization:use a semaphore

Like a mutex, but lets more than one thread through

Mutex with a counter

Checks availability, then acquires one count

When done, releases one count, unblocking others

Synchronization is about blocking

Allows you to control access to code and data

Protects areas of code that shouldnt be left to chance

Worker threads

Thread pools

Producer / Consumer

Will use .NET for examples

It is simple when simple, and fiendish when complex

Watch out for race conditions: lock often to prevent

Watch for deadlocks: dont lock too much

Watch for incomplete locks: lock carefully

Lock for the smallest amount of time

If possible, lock for consistency

then copy the data and use it locally

Instead of blocking on locks, wait with a timeout

Use lots of debug logging if youre in trouble

what every web and app developer should know about multithreading

Technology

function scope

retain predictability

avoid needing

bad threading

functional

local storage

side effects

mylocalx xset