Syllabus: 
COP 5255 Concurrent Programming

Spring 2008

Class web page

Description (3 credit hours)

A concurrent program contains several "threads of control" that execute at the same time. Each thread may have its own processor, or the system may switch between threads, simulating parallelism. In either case, writing correct and efficient concurrent programs is fundamentally more difficult than normal sequential programs. In the past, concurrent programming has been primarily done by specialists. Now,  due to he ubiquity of GUI and  web-based applications whose performance can often be improved significantly with the  use of concurrency, as well as the availability of multicore PCs,  concurrent programming promises to become much more widespread.

 

This course will provide an in-depth overview of underlying principles as well as practical programming techniques that can be used to construct well-engineered concurrent programs. Topics include notions of atomicity, safety, and liveness; techniques for reasoning about concurrent programs; synchronization and communication; memory models; program structuring; and multithreaded services and servlets. Students will apply concepts learned in the course to implement a non-trivial multithreaded application.

Texts

No textbooks are required.  Slides and/or notes will be provided.

The following references may be useful:

• Goetz, et. al.  Java: Concurrency in Practice.  Addison Wesley.  2006
• Mattson, Sanders, and Massingill.  Patterns for Parallel Programming.  Addison Wesley. 2005
• Andrews.  Concurrent Programming: Principles and Practice.  Benjamin/Cummings.  1991.

Software

Programming exercises will be done in Java.  Prior knowledge of Java will be helpful but is not required.

Topics 

• Concurrent programming  in Java
• Atomicity and concurrency
• Assertions and interference freedom
• Safety and synchronization
• Memory models
• Patterns for safety:  immutable classes, fully synchronized objects, containment
• Liveness and deadlock
• Guarded methods:  design and implementation using  synchronized blocks and semaphores
• Lock free  and non-blocking synchronization
• Failure and cancellation
• Structuring  and refactoring concurrent object-oriented programs
• Parallel Programming: patterns and languages
• Topics in distributed programming

• Alternative programming models (tuple spaces, etc.)

Homework

• During the first part of the semester, we will have a series of short programming exercises in Java to be done individually.
• During the second part of the semester, we will have a larger assignment to be done in pairs (optionally individually).  This project will require a written report and demo.  All on campus students are required to participate as testers for other students demos.  Testing will be done during the scheduled class time.
• Pencil and paper exercises will also be assigned throughout the semester.

Grading

Exam make-up and late homework policies

With the exception of the final project, late homework will be accepted with a late penalty up to three days after the due date and time. The late penalty is 10% per 12 hours past the due date and time.  Deadlines will be strictly enforced and no extensions granted, however, to provide students with some flexibility, the lowest short assignment grade will be dropped.   No late submissions or demos of the final project will be accepted.

---

 

Last updated: 
 ©Beverly A. Sanders, 2008