
1. Concurrent Programming

You Should Know The Answers To These Questions:
- What is the distinction between "concurrency" and "parallelism"?
- What are classical applications of concurrent programming?
- Why are concurrent programs more complex than sequential ones?
- What are "safety" and "liveness"? Give examples.
- How do you create a new thread in Java?
- What states can a Java thread be in? How does it change state?
- When should you declare a method to be synchronized?

Can You Answer The Following Questions?
- What is an example of a "race condition"?
- When will a concurrent program run faster than an equivalent sequential one?
- When will it be slower?
- What is the difference between deadlock and starvation?
- What happens if you call wait or notify outside a synchronized method
  or block?
- When is it better to use synchronized blocks rather than methods?

2. Safety

You Should Know The Answers To These Questions:
- Why are immutable classes inherently safe?
- Why doesn't a "relay" need to be synchronized?
- What is "balking"? When should a method balk?
- When is partial synchronization better than full synchronization?
- How does containment avoid the need for synchronization?

Can You Answer The Following Questions?
- When is it all right to declare only some methods as synchronized?
- When is an inner class better than an explicitly named class?
- What liveness problems can full synchronization introduce?
- Why is it a bad idea to have two separate critical sections in a
  single method?
- Does it matter if a contained object is synchronized or not?

3. State-dependent Action

You Should Know The Answers To These Questions:
- What kinds of liveness problems can occur in concurrent programs?
- What is the difference between livelock and deadlock?
- When should methods recheck guard conditions after waking from a wait()?
- Why should you usually prefer notifyAll() to notify()?
- When and where should you issue notification?

Can You Answer The Following Questions?
- How can you detect deadlock? How can you avoid it?
- What is the easiest way to guarantee fairness?
- When are guarded methods better than balking?
- What is the best way to structure guarded methods for a class if you
  would like it to be easy for others to define correctly functioning
  subclasses?
- Is the complexity of delegating notifications worth it?

4. Asynchronous Methods

You Should Know The Answers To These Questions:
- What general form does an asynchronous invocation take?
- When should you consider using asynchronous invocations?
- In what sense can a direct invocation be "asynchronous"?
- Why (and how) would you use "inner classes" to implement asynchrony?
- What is "early reply", and when would you use it?
- What are "futures", and when would you use them?
- How can implement futures and early replies in Java?

Can You Answer The Following Questions?
- Why are servers commonly structured as thread-per-message gateways?
- Which of the concurrency abstractions we have discussed till now can
  be implemented using one-slot-buffers as the only synchronized
  objects?
- When are futures better than early replies? Vice versa?

5. Fine-grained Synchronization

You Should Know The Answers To These Questions:
- What are "condition objects"? How can they make your life easier? Harder?
- What is the "nested monitor problem"? How can you avoid it?
- What are "permits" and "semaphores"? When is it natural to use them?
- Why (when) can semaphores use notify() instead of notifyAll()?
- When should you consider allowing methods to be concurrently available?
- What kinds of policies can apply to concurrent Readers and Writers?
- How do optimistic methods differ from guarded methods?

Can You Answer The Following Questions?
- What is the easiest way to avoid the nested monitor problem?
- What assumptions do nested monitors violate?
- How can the obvious implementation of semaphores (in Java) violate fairness?
- How does "partial synchronization" differ from "concurrently
  available methods"?
- When should you prefer optimistic methods to guarded methods?

6. Architectural Styles for Concurrency

You Should Know The Answers To These Questions:
- What is a Software Architecture?
- What are advantages and disadvantages of Layered Architectures?
- What is a Flow Architecture? What are the options of tradeoffs?
- What are Blackboard Architectures? What are the options and tradeoffs?

Can You Answer The Following Questions?
- How would you model message-passing agents in Java?
- How would you classify Client/Server architectures?
- Are there other useful styles we haven't yet discussed?
- How can we prove that the Active Prime Sieve is correct? Are you sure
  that new Active Primes will join the chain in the correct order?
- Which Blackboard styles are better when we have multiple processors?
- Which are better when we just have threads on a monoprocessor?

7.  Coordination Models and Languages

8. Coordination Components in Java

9. Object-Based Concurrency

You Should Know The Answers To These Questions:
- What is the difference between active and passive objects?
- What is the difference between client- and server-driven concurrency?
- What different ways are there to introduce concurrency in applications?
- What are local and remote delays?
- What are the usual ways to implement local delays?
- How can an object avoid remote delays?

Can You Answer The Following Questions?
- What kinds of problems cannot be easily solved with purely sequential objects?
- When is the active/passive model useful when programming in Java?
- How could you implement an active object in Java? Why would you do so?
- How would you implement futures in Java?
- Suppose you want to extend a class that makes use of synchronize,
  wait() and notify() - what would you have to be careful about in your
  subclass extensions?

10. Petri Nets

You Should Know The Answers To These Questions:
- How are Petri nets formally specified?
- How can nets model concurrency and synchronization?
- What is the "reachability set" of a net? How can you compute this set?
- What kinds of Petri nets can be modelled by finite state automata?
- How can a (bad) implementation of a Petri net deadlock even though
  there are enabled transitions?
- If you implement a Petri net model, why is it a good idea to realize
  transitions as "gateways"?

Can You Answer The Following Questions?
- What are some simple conditions for guaranteeing that a net is bounded?
- How would you model the Dining Philosophers problem as a Petri net?
- Is such a net bounded? Is it conservative? Is it live?
- What could you add to Petri nets to make them Turing-complete?
- What constraints could you put on a Petri net to make it fair?

11. The pi Calculus

12. JPict - the pi-Calculus in Java

