More Than Java Concurrency

Darren.Wang(王福强)

More Than Java Concurrency

Thursday, January 20, 2011

Agenda

More Than Java Concurrency? What’s More?

Several Concurrency Models/Patterns

Case Study

Questions?

The end


Why concurrency?

为了反映一些问题的逻辑结构

为了应对相互独立的多台物理设备

为了同时在多部处理器上运行以提高性能


What concurrency offers

reduce latency

divide and conquer, run in parallel reduce the latency

hide latency

asynchronous

increase throughput

more tasks can be run without wasting available computing power


What we do with Java Concurrency

State, That’s all of the about.

Atomicity - keep state intact

Visibility - make right state access


When Things Go Wrong


What If ...


What We Will Talk Today

Share-State Concurrency

Share-Nothing Concurrency

Software Transaction Memory

Data-Flow Concurrency


Share-State Concurrency


JMM Simplified

Picture borrowed from <<Java多线程设计模式>>


JMM escalation


How to deal with?

How many ways can you count?

Here we go...


Immutability

immutable anytime

Immutable Object

immutable before publishing

Map & ConcurrencyMap

(1)To Find More in book <<Java Concurrency In Practice>>


Confinement

Thread Confinement

Thread-Specific Variables(ThreadLocal)

Stack Confinement

Method Stack Scope


Synchronization

Synchronized Block(Implicit Lock)

Explicit Lock

Volatile (Partial Synchronization Support)


Gotchas With Synchronization

Deadlock

how to prevent it?

Live lock

Starvation



Deadlock

how to prevent it?

Live lock

Starvation

Resource Re-ordering



Deadlock

how to prevent it?

Live lock

Starvation

Resource Re-ordering

Periodic Retry


Performance Tuning with Synchronization

reduce the time of holding locks

break global locks into fine-grained locks

what coming next?


CAS

Compare-And-Set | Compare-And-Swap

java.util.concurrent.atomic after Java5

AtomicInteger

AtomicLong

AtomicBoolean

AtomicReference


Section Conclusion

Pessimistic Model

Lock-Based

Optimistic Model

Lock-Free



AKA. Message Passing Concurrency

Confinement In a Big Picture


Actor Model

First proposed by Carl Hewitt in 1973

improved by Gul Agha

An Actor Can:

change internal state

send messages to peer actors

create new actors

migrate to another computing host


Actor Rocks

more light weight

event based actors of akka can create 6.5million on 4 G RAM (600 bytes each)

much easier, just send messages

counter ! tick


Actors Available

Erlang Platform

Scala Platform

TBA, EBA

Lift Actor, Akka Actor

Java Platform

Kilim, SALSA(simple actor language, system and architecture)

Other


Actor Almighty?

when we really have shared states, e.g. bank account?

when we need to form unified consensus

when we need synchronous behavior

a bit verbose compared to method dispatch


Section Conclusion

Actor Model Rocks In Some Situations, But not all

Share Nothing Simplify the Architecture Design

Prefer Share Nothing to Share State If Possible


You Know Lego, Right?


Case Study I

Session Management

Centralized Storage

memcached, database...

Client-Specific Storage

secure cookie

other local-storage mechanism


Case Study II

Map-Reduce

When Share Nothing can rock in

When Share State Is a Must


Case Study III

Symmetric Cluster

Share Nothing

Asymmetric Cluster

Share State


STM

Software Transaction Memory

Transaction operations execute in the own thread in parallel, commit will cause One to be successful and others to abort or retry


Sounds Familiar?

Optimistic Model

Can be nested

Simple Programming Model


Available Solutions

Clojure

Concurrent Haskell

STM .Net

More...


Cons

All operations in scope of a transaction:

need to be idempotent

can’t have side-effects

Memory Concern

Conflicting Rate Concern


Section Conclusion

optimistic model

simple programming model

with restrictions

which may cause limitations(MS drops STM)


Data-Flow Concurrency

AKA. Declarative Concurrency


Have you ever...


Features

Single Assignment Variables

Data-States trigger process flow


Available Languages

LabView图形化编程语言


Usage Scenarios

Signal Process System


Typical Operations

create a data-flow variable

wait for the variable to be bound

bind the variable


Limitations

Can’t have side-effects

Exceptions

IO

Others


Section Conclusion

Data Based Concurrency


comparison of common facilities

Executor (Agent)

Actor (HawtDispatch)

STM

Transactor(Actor + STM)


Thank You


The End


More Than Java Concurrency

Technology

Transcript of More Than Java Concurrency