Concurrent programming language: Difference between revisions

Concurrent programming languages are programming languages that use language constructs for concurrency. These constructs may involve multi-threading, support for distributed computing, message passing, shared resources (including shared memory) or futures (known also as promises).

In some languages communication between concurrent parts of an application is hidden from the programmer (e.g., by using futures), while in others it must be handled explicitly. Explicit communication can be divided into two classes:

1. Shared-memory communication, in which the concurrent parts communicate by altering the contents of shared memory locations (exemplified by Java and C#). This style of concurrent programming usually requires the application of some form of locking (e.g., mutexes, semaphores, or monitors) to coordinate between threads.
2. Message-passing communication, in which concurrent parts communicate by exchanging messages (exemplified by Erlang and Occam). The exchange of messages may be carried out asynchronously (i.e. "send, pray, and if no acknowledgment send again"), or may use a rendezvous style in which the sender blocks until the message is received. Message-passing concurrency tends to be far easier to reason about than shared-memory concurrency, and is typically considered a more robust form of concurrent programming. A wide variety of mathematical theories for understanding and analyzing message-passing systems are available, including the Actor model, and various Process calculi.

Today, the most commonly used programming languages that have specific constructs for concurrency are Java and C#. Both of these languages fundamentally use a shared-memory concurrency model, with locking provided by monitors (although message-passing models can and have been implemented on top of the underlying shared-memory model).

Of the languages that use a message-passing concurrency model, Erlang is probably the most widely used in industry at present.

Languages where concurrency is important

• Ada
• Afnix – concurrent access to data is protected automatically (previously called Aleph, but unrelated to Alef)
• Alef – concurrent language with threads and message passing, used for systems programming in early versions of Plan 9 (operating system)
• ChucK – domain specific programming language for audio
• Cilk – a concurrent C
• Cω – C Omega, a research language extending C#, uses asynchronous communication
• Concurrent Pascal – by Brinch-Hansen
• Corn
• E – uses promises, ensures deadlocks cannot occur
• Erlang – uses asynchronous message passing with nothing shared
• Join Java – concurrent language based on the Java programming language
• Joule – dataflow language, communicates by message passing
• Limbo – relative of Alef, used for systems programming in Inferno (operating system)
• Oz – multiparadigm language, supports shared-state and message-passing concurrency, and futures
  • Mozart Programming System – multiplatform Oz
• MultiLisp – Scheme variant extended to support parallelism
• occam – influenced heavily by Communicating Sequential Processes (CSP).
  • occam-π – a modern variant of occam, which incorporates ideas from Milner's π-calculus
• Pict – essentially an executable implementation of Milner's π-calculus
• SALSA – actor language with token-passing, join, and first-class continuations for distributed computing over the Internet
• SR – research language

Note that many of these languages are intended more as research languages (e.g., Pict) than as languages for production use. However, several of the examples (such as Erlang, Limbo, and occam) have seen industrial use at various times in the last 20 years.

Many other languages provide support for concurrency in the form of libraries (on level roughly comparable with the above list).