Lecture on Java Concurrency Day 2 on Feb 4, 2009.
Download as PPT, PDF0 likes442 views
The document discusses concurrency in programming, focusing on performance, correctness, and design concerns such as deadlocks and liveness issues. It highlights concepts like lock-ordering deadlock, memory barriers, and context switching overhead, as well as design steps for managing shared resources and critical sections. Additionally, it touches on the use of worker threads and instance management in environments like Java EE.
Lecture on Java Concurrency Day 2 on Feb 4, 2009.
- 1. Practical Concurrency January, 2009 http://javadom.blogspot.com/2011/06/lecture-on-java-concurrency-day-2.html
- 2. Day 2 (9am, Feb 4, 2009) Concurrency Concerns Performance Concurrency Design
- 3. 2-1 Concurrency Concerns Correctness Liveness
- 4. Correctness (Multi-threaded Safety) Conflicts Read-write conflicts Write-write conflicts
- 5. Liveness Blockages Lock Wait Input CPU contention Failure
- 6. Deadlock A situation wherein two or more competing actions are waiting for the other to finish, and thus neither ever does. Lock-ordering deadlock Dynamic lock-ordering deadlock Resource deadlock Thread-starvation deadlock
- 7. Livelock similar to a deadlock, except that the states of the processes involved in the livelock constantly change with regard to one another, none progressing
- 8. 2-2 Performance Amdahl’s law Context Switch Overhead Memory Barrier Overhead
- 9. Amdahl’s law
- 10. Context Switch Overhead All the Registers Program Control Block Kernel stack User Area Text/data/ stack
- 11. Memory Barrier a class of instructions which cause a central processing unit (CPU) to enforce an ordering constraint on memory operations issued before and after the barrier instruction. Assures ordered access and memory visibility in multi-processor environments Accessing volatile fields are usually implemented using memory barrier
- 12. 2-3 Concurrency Design Concurrency Design Step Concerns Objects in Worker Thread Model Collection Design
- 13. Steps of Designing Concurrency Identify Shared Resources Identify Critical Sections Design Lock Granularity Check multiple locking sanity Check long critical sections Check possible locking order problems
- 14. Concerns on Designing Concurrency Liveness Deadlock Starvation Waiting Performance Context switching overhead Lock contention
- 15. Further considerations Thread confinement Locking itself is not critical overhead Lock contention and context switching is.
- 16. Worker Threads Worker threads One thread to execute many unrelated tasks Aka., background threads or thread pools (when more than one thread is used) Object life cycle and work threads Instance sharing New instance per work Worker threads and Instance variables
- 17. Worker Threads and Objects JavaEE EJB Session Bean Stateless session bean objects are pooled The container assures the serialized access to each objects (so, always thread-safe) Statefull session bean might throw ConcurrentAccessException JavaEE Servlet Servlet object life cycle Objects per Request/Session/Page/Application lifecycle
- 18. Worker Threads and Objects (2) JMX MBean (Local/Connector) Creates new thread per messages Just like the servlet model ProBus Process(or Flow) Use the same Flow class and LProcess objects are created per flow instances (contentions against Lprocess and …) BizMaster Workflow Process Per-process class is generated and no process instances (contentions against RuntimeContext and …) ProBus Adapter Rule Just like the servlet model
Editor's Notes
- #7: Deadlock :circular dependencies among locks Livelock : a continously retried action countinously fails
- #10: rs represents the ratio of the sequential portion in one program
- #11: Process Context Switch Overhead : text/data/stack (user area), kernel stack Thread Context Switch Overhead : stack (user), kernel stack