Concurrent programming language

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).

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

1. Shared-memory communication, in the which concurrent parts communicate by changing shared memory locations. 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 messages are sent to recipients as in the Actor model and Process calculi. 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. Messages can be asynchronous (aka "send, pray, and if no acknowledgment send again"), as packets on the Internet, or may use a rendezvous style in which the sender blocks until the message is received, as in TCP on the Internet and synchronous process calculi.

Today the most commonly used programming lanuages with specific constructs for concurrency are Java and C# with their multi-threading and locking. These programming languages make use of both message-passing and shared-memory communication.

Languages where concurrency is a primary design motive

• Ada
• Afnix - concurrent access to data is protected automatically (under name Aleph the language was originally used for the 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 Java language
• Joule - dataflow language, communicates by message passing
• Limbo - successor to Alef (Afnix), used 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 paralelism
• Occam - influenced heavily by Communicating sequential processes.
• Pict - essentially an executable implementation of Milner's Pi-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 concurency in the form of libraries (on level roughly comparable with the above list).