here - Stefan-Marr.de

2.3. Concurrent vs. Parallel Programming: Definitions
on top of lower-level abstractions, which can fall into a different category. For
instance, as discussed after these definitions, parallel programming abstractions
are often implemented in terms of concurrent programming abstractions.
Thus, these definitions have to be interpreted on a fixed and common
abstraction level.
Definition 1. Parallel programming is the art of devising a strategy to coordinate
collaborating activities to contribute to the computation of an overall result by
employing multiple computational resources.
Definition 2. Concurrent programming is the art of devising a strategy to coordinate
independent activities at runtime to access shared resources while preserving
the resources’ invariants.
This means that parallel programming is distinct from concurrent programming
because it provides techniques to employ multiple computational resources,
while concurrent programming provides techniques to preserve semantics,
i. e., the correctness of computations done by independent interacting
activities that use shared resources.
Furthermore, an important aspect of parallel programming is the decomposition
of a problem into cooperating activities that can execute in parallel
to produce an overall result. Therefore, the related concepts include mechanisms
to coordinate activities and communicate between them. This coordination
can be done by statically planing out interactions for instance to reduce
communication, however, it usually also needs to involve a strategy for the
communication at runtime, i. e., the dynamic coordination.
In contrast, concurrent programming concepts include techniques to protect
resources, for instance by requiring the use of locks and monitors, or by
enforcing properties such as isolation at runtime, preventing undesirable access
to shared resources. The notion of protecting invariants, i. e., resources is
important because the interacting activities are independent. They only interact
based on conventions such as locking protocols or via constraint interfaces
such as messaging protocols to preserve the invariants of the share resources.
The nature of activities remains explicitly undefined. An activity can therefore
be represented for instance by a light-weight task, a thread, or an operating
system process, but it could as well be represented by the abstract notion
of an actor.
Note that these definitions do not preclude the combination of concurrent
and parallel programming. Neither do they preclude the fact that programming
concepts can build on each other, as discussed in the beginning of this
21