| Free tutorials for Java, Eclipse and Web programming |
Version 0.9
Copyright © 2008 - 2009 Lars Vogel
15.11.2009
| Revision History | ||
|---|---|---|
| Revision 0.0.1 | 28.12.2008 | Lars Vogel |
| First DRAFT | ||
| Revision 0.2 | 12.01.2009 | Lars Vogel |
| Added Join-Fork | ||
| Revision 0.3 | 04.05.2009 | Lars Vogel |
| Concurrency moved to own article, restructed article | ||
| Revision 0.4 | 05.05.2009 | Lars Vogel |
| Thread Pools, Callable and Futures part of the article re-written | ||
| Revision 0.5 | 12.06.2009 | Lars Vogel |
| Added deadlock description | ||
| Revision 0.6 | 20.07.2009 | Lars Vogel |
| Example for synchronized | ||
| Revision 0.7 | 21.07.2009 | Lars Vogel |
| Defensive copy | ||
| Revision 0.8 | 01.11.2009 | Lars Vogel |
| Added nonblocking algorithm description | ||
| Revision 0.9 | 15.11.2009 | Lars Vogel |
| Added CAS explicit operation | ||
Table of Contents
Concurrency is the ability to run several parts of a program or several programs in parallel. Concurrency can highly improve the throw-put of a program if certain tasks can be performed asynchronously or in parallel.
Almost every computer nowadays has several CPU's or several cores within one CPU. The ability to leverage theses multi-cores can be the key for a successful high-volume application.
The distinction between processes and threads is important.
Process: A process runs independently and isolated of other processes. It cannot directly access shared data in other processes. The resources of the process are allocated to it via the operating system, e.g. memory and CPU time.
Threads: threats are co called lightweight processes which have their own call stack but an access shared data. Every thread has its own memory cache. If a thread reads shared data it stores this data in its own memory cache. A thread can re-read the shared data, when this happens in Java will be explained in Java memory model part of this article.
Within a Java application you work with several threads to archive parallel processing or asynchronously behavior.
Concurrency promises to perform certain task faster as these tasks can be divided into subtasks and these subtasks can be executed in parallel. Of course the runtime is limited by parts of the task which can be performed in parallel.The theoretical possible performance gain can be calculated by Amdahl's Law. If F is the percentage of the program which can not run in parallel and N is the number of processes then the maximum performance gain is 1/ (F+ ((1-F)/n)).
Threads have there own call stack but can also access shared data. Therefore you have two basic problems, visibility and access problems.
A visibility problem occurs if one thread reads shared data which is later changed by other thread and if thread A does not see this change.
A access problem occurs if several thread trying to access and change the same shared data at the same time.
Visibility and access problem can lead to
Liveness failure: The program does not react anymore due to problems in the concurrent access of data, e.g. deadlocks.
Safety failure: The program creates incorrect data.