book

Concurrent Programming in Java™: Design Principles and Patterns, Second Edition

Name: Concurrent Programming in Java™: Design Principles and Patterns, Second Edition
Author: Doug Lea
ISBN: 0201310090

by Doug Lea

October 1999

Intermediate to advanced

432 pages

9h 13m

English

Addison-Wesley Professional

Read now

Unlock full access

Copyright
Acknowledgments
1. Concurrent Object-Oriented Programming
1.1. Using Concurrency Constructs1.1.1. A Particle Applet1.1.1.1. ParticleNotes:1.1.1.2. ParticleCanvas1.1.1.3. ParticleAppletNotes:1.1.2. Thread Mechanics1.1.2.1. Construction1.1.2.2. Starting threads1.1.2.3. Priorities1.1.2.4. Control methods1.1.2.5. Static methods1.1.2.6. ThreadGroups1.1.3. Further Readings1.2. Objects and Concurrency1.2.1. Concurrency1.2.2. Concurrent Execution Constructs1.2.2.1. Computer systems1.2.2.2. Processes1.2.2.3. Threads1.2.2.4. Tasks and lightweight executable frameworks1.2.3. Concurrency and OO Programming1.2.3.1. Sequential OO programming1.2.3.2. Event-based programming1.2.3.3. Concurrent systems programming1.2.3.4. Other concurrent programming languages1.2.4. Object Models and Mappings1.2.4.1. Object models1.2.4.2. Sequential mappings1.2.4.3. Active objects1.2.4.4. Mixed models1.2.5. Further Readings1.2.5.1. Concurrent programming1.2.5.2. Models1.2.5.3. Distributed systems1.2.5.4. Real-time programming1.3. Design Forces1.3.1. Safety1.3.1.1. Attributes and constraints1.3.1.2. Representational constraints1.3.2. Liveness1.3.3. Performance1.3.4. Reusability1.3.4.1. Closed subsystems1.3.4.2. Open systems1.3.4.3. Documentation1.3.5. Further Readings1.4. Before/After Patterns1.4.1. Layering1.4.2. Adapters1.4.3. Subclassing1.4.3.1. Template methods1.4.4. Method Adapters1.4.5. Further Readings
2. Exclusion
2.1. Immutability2.1.1. Applications2.1.1.1. Abstract Data Types (ADTs)2.1.1.2. Value containers2.1.1.3. Sharing2.1.2. Construction2.2. Synchronization2.2.1. Mechanics2.2.1.1. Objects and locks2.2.1.2. Synchronized methods and blocks2.2.1.3. Acquiring and releasing locks2.2.1.4. Statics2.2.2. Fully Synchronized Objects2.2.3. Traversal2.2.3.1. Synchronized aggregate operations2.2.3.2. Indexed traversal and client-side locking2.2.3.3. Versioned iterators2.2.3.4. Visitors2.2.4. Statics and Singletons2.2.5. Deadlock2.2.6. Resource Ordering2.2.7. The Java Memory Model2.2.7.1. Atomicity2.2.7.2. Visibility2.2.7.3. Ordering2.2.7.4. Volatile2.2.8. Further Readings2.3. Confinement2.3.1. Confinement Across Methods2.3.1.1. Sessions2.3.1.2. Alternative protocols2.3.2. Confinement Within Threads2.3.2.1. Thread-specific fields2.3.2.2. ThreadLocal2.3.2.3. Applications and consequences2.3.3. Confinement Within Objects2.3.3.1. Adapters2.3.3.2. Subclassing2.3.4. Confinement Within Groups2.3.4.1. Rings2.3.5. Further Readings2.4. Structuring and Refactoring Classes2.4.1. Reducing Synchronization2.4.1.1. Accessors2.4.1.2. Double-check2.4.1.3. Open calls2.4.2. Splitting Synchronization2.4.2.1. Splitting classes2.4.2.2. Splitting locks2.4.2.3. Isolating fields2.4.2.4. Linked data structures2.4.3. Read-Only Adapters2.4.4. Copy-on-Write2.4.4.1. Internal copy-on-write2.4.4.2. Optimistic Updates2.4.4.3 . Atomic commitment2.4.5. Open Containers2.4.5.1. Internal disciplines2.4.5.2. External disciplines2.4.5.3. Multilevel containment2.4.6. Further Readings2.5. Using Lock Utilities2.5.1. Mutexes2.5.1.1. Method adapters2.5.1.2. Back-offs2.5.1.3. Reorderings2.5.1.4. Non-block-structured locking2.5.1.5. Lock Ordering Managers2.5.2. Read-Write Locks2.5.3. Further Readings
3. State Dependence
3.1. Dealing with Failure3.1.1. Exceptions3.1.1.1. Abrupt termination3.1.1.2. Continuation3.1.1.3. Rollback3.1.1.4. Roll-forward3.1.1.5. Retry3.1.1.6. Handlers3.1.2. Cancellation3.1.2.1. Interruption3.1.2.2. IO and resource revocation3.1.2.3. Asynchronous termination3.1.2.4. Resource control3.1.2.5. Multiphase cancellation3.1.3. Further Readings3.2. Guarded Methods3.2.1. Guarded Suspension3.2.1.1. Guards3.2.1.2. State-based message acceptance3.2.1.3. Defining logical control state3.2.2. Monitor Mechanics3.2.3. Guarded Waits3.2.3.1. Interrupted waits3.2.4. Notifications3.2.4.1. Slipped conditions and missed signals3.2.4.2. Single notifications3.2.5. Timed Waits3.2.6. Busy Waits3.2.6.1. Efficiency3.2.6.2. Scheduling3.2.6.3. Triggering3.2.6.4. Synchronizing actions3.2.6.5. Implementations3.3. Structuring and Refactoring Classes3.3.1. Tracking State3.3.1.1. Channels and bounded buffers3.3.1.2. State variables3.3.2. Conflict Sets3.3.2.1. Implementation3.3.2.2. Variants and extensions3.3.3. Subclassing3.3.3.1. Readers and Writers3.3.3.2. Layering Guards3.3.3.3. Inheritance anomalies3.3.4. Confinement and Nested Monitors3.3.5. Further Readings3.4. Using Concurrency Control Utilities3.4.1. Semaphores3.4.1.1. Mutual exclusion locks3.4.1.2. Resource pools3.4.1.3. Bounded buffers3.4.1.4. Synchronous channels3.4.1.5. Fairness and scheduling3.4.1.6. Priorities3.4.2. Latches3.4.2.1. Latching variables and predicates3.4.3. Exchangers3.4.4. Condition Variables3.4.5. Further Readings3.5. Joint Actions3.5.1. General Solutions3.5.1.1. Structure3.5.1.2. Classes and methods3.5.1.3. Liveness3.5.1.4. Example3.5.2. Decoupling Observers3.5.3. Further Readings3.6. Transactions3.6.1. Transaction Protocols3.6.2. Transaction Participants3.6.2.1. Interfaces3.6.2.2. Implementations3.6.3. Creating Transactions3.6.3.1. Example3.6.4. Vetoable Changes3.6.5. Further Readings3.7. Implementing Utilities3.7.1. Acquire-Release Protocols3.7.2. Delegated Actions3.7.2.1. Design steps3.7.2.2. Bounded buffers3.7.2.3. Collapsing classes3.7.3. Specific Notifications3.7.3.1. Design steps3.7.3.2. FIFO semaphores3.7.4. Further Readings
4. Creating Threads
4.1. Oneway Messages4.1.1. Message Formats4.1.2. Open Calls4.1.3. Thread-Per-Message4.1.3.1. Executors4.1.4. Worker Threads4.1.4.1. Design choices4.1.4.2. Event queues4.1.4.3. Timers4.1.5. Polling and Event-Driven IO4.1.5.1. Event-driven tasks4.1.5.2. Triggering4.1.6. Further Readings4.2. Composing Oneway Messages4.2.1. Composition4.2.1.1. Representations4.2.1.2. Stages4.2.1.3. Scripting4.2.2. Assembly Line4.2.2.1. Representations4.2.2.2. Interfaces4.2.2.3. Adapters4.2.2.4. Sinks4.2.2.5. Connections4.2.2.6. Linear stages4.2.2.7. Combiners4.2.2.8. Collectors4.2.2.9. Dual output stages4.2.2.10. Sources4.2.2.11. Coordination4.2.3. Further Readings4.3. Services in Threads4.3.1. Completion Callbacks4.3.1.1. Interfaces4.3.1.2. Implementations4.3.1.3. Guarding callback methods4.3.2. Joining Threads4.3.3. Futures4.3.3.1. Callables4.3.4. Scheduling Services4.3.5. Further Readings4.4. Parallel Decomposition4.4.1. Fork/Join4.4.1.1. Task granularity and structure4.4.1.2. Frameworks4.4.1.3. Defining tasks4.4.1.4. FibonacciNotes:4.4.1.5. Linking subtasks4.4.1.6. CallbacksNotes:4.4.1.7. Cancellation4.4.2. Computation Trees4.4.2.1. Building and using trees4.4.3. Barriers4.4.4. Further Readings4.5. Active Objects4.5.1. CSP4.5.1.1. Processes and channels4.5.1.2. Composition4.5.1.3. JCSP4.5.1.4. Dining philosophers4.5.2. Further Readings

Content preview from Concurrent Programming in Java™: Design Principles and Patterns, Second Edition

Chapter 4. Creating Threads

It is impossible to categorize all the ways to exploit the functionality associated with threads. But two general approaches can be distinguished by their points of view on the statement:

new Thread(aRunnable).start();

Is this a fancy way to invoke a method (i.e., a Runnable's run method), or is it a way to create a fancy object (i.e., a new instance of class Thread)? Clearly it is both, but focusing on one aspect versus the other leads to two approaches to using threads that were implicit in discussions in Chapter 1:

Task-based. Here, the main reason to use a thread is to asynchronously invoke a method that performs some task. The task might range from a single method to an entire session. Thread-based techniques can ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0201310090Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Concurrent Programming in Java™: Design Principles and Patterns, Second Edition

by Doug Lea

Chapter 4. Creating Threads

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.