SE 552 - Concurrent Software
Development
Reading List and Useful Information
Table of contents
| Textbooks Supplements to the Textbooks On-line Articles General Topics Java |
Textbooks
Required Text:
 |
Java Concurrency in Practice,
by Brian Goetz, with Tim
Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes, Doug Lea.
Addison-Wesley, 2006, ISBN: 0-321-34960-1
|
Recommended Text:
 |
Java Threads, Third Edition, 3rd edition, Scott Oaks, Henry Wong, O'Reilly, 2006. ISBN: 0-596-00782-5 |
 |
A very good book you might
find on the used book market (it is no
longer sold new) is: Concurrent Programming in Java, 2nd edition, Doug Lea, Addison-Wesley, 2000. ISBN: 0-201-31009-0 It may be unavailable except as a used book as it is now out of print. |
Supplements to the Textbooks
On-line Articles
General Topics
Java
- JavaTM 2 Platform, Standard Edition, v 1.5.0 API Specification Full documentation (javadoc) on the classes used in the course.
- JDKTM 5.0 Documentation
- Thread (Java 2 Platform SE 5.0)
- Threads and Multithreading
- Threads: Doing Two or More Tasks at Once
- Sun's Java Tutorial on Concurrency
- Concurrency Utilities
- Concurrency Utilities Overview
- Concurrent
Programming with J2SE 5.0
Patterns and Concurrency
Articles
- Introduction to Java threads
- JDC
Tech Tips:
- Minimal Synchronization Techniques (PDF - 28 pages)
- Study Notes - Threads
- Concurrent Programming in Java: Creating Threads (69 pages)
- Java Thread API
- Threads: Doing Two or More Tasks at Once
- Dining_philosophers_problem
- Java API for Semaphores
- Concurrent Programming with J2SE 5.0
- Java API for ReentrantLock
- Java API for ReentrantReadWriteLock
- Java Feature — Concurrent Programming and Locking in J2SE 5.0
- Threads and Multithreading
- Concurrency Utilities Overview
- Thread (Java 2 Platform SE 5.0)
- Concurrent Programming with J2SE 5.0
- Concurrency
control
- Optimistic Concurrency Control
- Introduction to Concurrency Control
- Rob Pike Introduction to Concurrent Programming ProgrammingLec1.pdf
- Concurrent Programming - SwinBrain
- Concurrent Programming - Channel - SwinBrain
- Concurrent Programming - Barrier - SwinBrain
- Concurrent Programming - Semaphore - SwinBrain
- Race Conditions and Mutual Exclusion
- Java theory and practice: Thread pools and work queue
- Realtime programming in Java: Part1
- Extending Java to Support Shared Resource Protection and Deadlock Detection in Threads Programming
- Java
World Articles on Thread Programming - Dated but of interest
- Programming
Java threads in the real world - Series of articles in JavaWorld (old
but illuminating)
- Programming Java threads in the real world, Part 1 A Java programmer's guide to threading architectures Programming Java threads isn't nearly as easy (or as platform-independent) as most books would have you believe, and all Java programs that use the AWT are multithreaded. This article is the first in a series that discusses the things you need to know to program threads in the real world. The article assumes you understand the language-level support for threads (the synchronized keyword, how monitors work, the wait() and notify() methods, and so on) and focuses on the legion of problems that arise when you try to use these language features.
- Java Toolbox: Programming Java threads in the real world, Part 2 This article, the second in a multipart series on threads, discusses the perils that can arise when you approach multithreading in a naive way. As is the case with the entire series, this article assumes reader familiarity with the basic thread-related parts of Java: the synchronized keyword and monitors, wait(), notify(), the basics of using the Thread class, and so forth. Here, Allen focuses on the more advanced problems encountered when programming Java threads in the real world.
- Programming Java threads in the real world, Part 3 Roll-your-own mutexes and centralized lock management In Parts 1 and 2 of this series on threads, Allen looked at some of the pitfalls of writing multithreaded applications in Java. This month, he starts looking at a few solutions. In particular, he looks at how and why you might want to roll your own exclusion semaphores, and presents a lock manager that will help you safely acquire multiple semaphores.
- Programming Java threads in the real world, Part 4 Condition variables and counting semaphores -- filling in a few chinks in Java's threading model This column continues where last month's column left off, presenting a few more implementations of classes that are useful when you're doing multithreading in Java. The two classes I'll discuss provide capabilities difficult to get using Java's threading primitives alone: a condition variable adds to wait the ability to not wait when the condition you're waiting for has already taken place; and a counting semaphore lets you control a pool of resources without sucking up machine cycles in polling loops. This month's column also discusses a few minor fixes to the code presented last month.
- Programming Java threads in the real world, Part 5 In an aside to his running series on programming Java threads in the real world, Allen prefaces this month's column with a look at one dangerous new "feature" of the Java 2 platform: the ability to produce noncompliant class files that will not run on a 1.1 Java virtual machine (JVM).
- Programming Java threads in the real world, Part 6 This month continues the thread theme by examining how to implement the Observer pattern (used by AWT/Swing for its event model) in a multithreaded environment. The article covers how to notify observers in an efficient, thread-safe way using code modeled after Java's AWTEventMulticaster. It also considers a few problems with AWT/Swing's use of Observer.
- Programming Java threads in the real world, Part 7 This month's column builds on the preceding installments of the Java Toolbox threads series, adding a few more tools to your multithreading arsenal. Columnist Allen Holub looks at reader/writer locks, which let multiple threads safely access a shared resource in an efficient way. (Multiple threads can read from the resource while only one thread at a time can write to it, and reads and writes can't occur at the same time.) He'll also discuss the Singleton pattern, with a focus on implementing it in a multithreaded environment, and critical sections, or blocks of code that can be executed by only one thread at a time.
- Programming Java threads in the real world, Part 8 The previous installment of Allen's ongoing Java threads series was devoted to low-level solutions to threading problems: locks of various sorts, timers, and so forth. This month's (penultimate) installment in the thread series moves on to discuss architectural solutions to threading problems. Allen looks at threads from the perspective of an object-oriented designer, and at how to implement threads in an object-oriented environment, focusing on the implementation of asynchronous methods. Along the way, he discusses the Command design pattern.
- Programming Java threads in the real world, Part 9 This article finishes up the series on threads with a discussion of two more architectural solutions to threading problems: a synchronous dispatcher (or "reactor") and an asynchronous dispatcher (or "active object"). These dispatchers can simplify the threading model considerably by letting you minimize -- and in some cases eliminate -- the need for method-level synchronization, thereby making it much easier to write and debug multithreaded applications
- Object Pools - Series of articles in JavaWorld (old but illuminating)
- Build your own ObjectPool in Java to boost app speed Object pooling allows the sharing of instantiated objects. Since different processes don't need to reinstantiate certain objects, there is no load time. And since the objects are returned to the pool, there is a reduction in garbage collection. Read on to learn, via the author's own example object pool design, how to employ this approach to boost performance and minimize memory use.
- Improve the robustness and performance of your ObjectPool In our previous object-pooling article Thomas E. Davis presented an example object pool design and described how to employ this approach to boost performance and minimize memory use. This month, after providing a quick recap of object pooling, Thomas will show you how to enhance the example pooling utility to include exception propagation and the clean-up thread. Thomas finishes by addressing some reader comments about the first article.
More Links
- Ch14.4 [Introduction to Concurrency] http://library.books24x7.com.ezproxy2.lib.depaul.edu/toc.asp?bkid=6833
- Chs 1--6 [Introduction to Concurrency] http://library.books24x7.com.ezproxy2.lib.depaul.edu/toc.asp?bkid=9105
- Section8: Ch 41-43 [Design Patterns] http://library.books24x7.com.ezproxy2.lib.depaul.edu/toc.asp?bkid=9696
- Book of Patterns relevant to this class [Design Patterns] http://library.books24x7.com.ezproxy2.lib.depaul.edu/toc.asp?bkid=3002
- Book of basic concurrent programming idioms [Introduction to Concurrency]http://library.books24x7.com.ezproxy2.lib.depaul.edu/toc.asp?bkid=7364
- Ch12 [Introduction to Concurrency] http://library.books24x7.com.ezproxy2.lib.depaul.edu/toc.asp?bkid=229
- Nice book on threads programming [Introduction to Concurrency] http://library.books24x7.com.ezproxy2.lib.depaul.edu/toc.asp?bkid=2190
- Code from book [Textbook] http://gee.cs.oswego.edu/dl/cpj/allcode.java
- Accomodating Java 5 [Textbook] http://gee.cs.oswego.edu/dl/cpj/updates.html
- Start with this: Javasoft intro [Introduction to Concurrency] http://java.sun.com/docs/books/tutorial/essential/threads/index.html
- More code for book [Textbook] http://gee.cs.oswego.edu/dl/cpj/classes/
- Threads and NIO [Textbook] http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf
- Concurrent Data Structures [JAVA] http://www-128.ibm.com/developerworks/java/library/j-jtp07233.html
- Concurrent Hash Map [JAVA] http://www-128.ibm.com/developerworks/java/library/j-jtp08223/
- ORielly:NIO http://www.onjava.com/pub/a/onjava/2002/03/06/topten.html?page=2
- Java:NIO http://java.sun.com/developer/technicalArticles/releases/nio/
- JavaWorld:NIO http://www.javaworld.com/javaworld/jw-09-2001/jw-0907-merlin.html
- Brian Goetz http://www.briangoetz.com/pubs.html
- Moores Law is dead! http://www.embedded.com/showArticle.jhtml?articleID=173402175
- MultiCore, Moore's Law http://www.google.com/search?hl=en&lr=&q=Moore%27s+law++multicore
- Double checked Locking in Creation http://www-128.ibm.com/developerworks/java/library/j-dcl.html
- JSR 133:FAQ [Unit 1] http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html
- Multicore crashes computing party http://www.eetimes.com/news/design/showArticle.jhtml?articleID=198700598
People
Wikipedia
- Semaphore_(programming)
- Monitor_(synchronization)
- Test_and_Test-and-set
- Mutual_exclusion
- Dining_philosophers_problem
- Concurrent_programming
- Test and Test-and-set
- Thread (computer science)
- Symmetric multiprocessing
UNIX/POSIX/Linux
Other Courses in Concurrency
- Concurrent Programming Using the Java Language
- Concurrent Programming
- CM20168:Programming Languages IV