Concurrent programming language

Concurrent programming languages are programming languages that use language constructs for Concurrency (computer science). These constructs may involve multi-threading, support for distributed computing, message passing programming, sharing (including Parallel Random Access Machine) or Future (programming) (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: #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., Mutual exclusion, Semaphore (programming), or Monitor (synchronization)) to coordinate between threads. #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 Internet Protocol on the Internet, or may use a rendezvous style in which the sender blocks until the message is received, as in Transmission Control Protocol on the Internet and synchronous process calculi.

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

= Languages where concurrency is important =

Ada programming language

Afnix programming language – concurrent access to data is protected automatically (previously called Aleph , but unrelated to Alef )

Alef programming language – 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 programming language

C – C Omega, a research language extending C#, uses asynchronous communication

Concurrent Pascal programming language – by Per Brinch Hansen

Corn Programming Language

E programming language – uses promises, ensures deadlocks cannot occur

Erlang programming language – uses asynchronous message passing with nothing shared

Join Java – concurrent language based on the Java programming language

Joule programming language – dataflow language, communicates by message passing

Limbo programming language – relative of Alef programming language, used for systems programming in Inferno (operating system)

Oz_programming_language – multiparadigm language, supports shared-state and message-passing concurrency, and futures

**Mozart Programming System – multiplatform Oz

MultiLisp – Scheme programming language variant extended to support paralelism

Occam programming language – influenced heavily by Communicating Sequential Processes (CSP).

Pict programming language – essentially an executable implementation of Milner s Pi-Calculus

SALSA programming language – actor language with token-passing, join, and first-class continuations for distributed computing over the internet

SR language – 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).