View source for JCSP

{{Notability|date=November 2014}}
'''JCSP''' is an implementation of [[communicating sequential processes]] (CSP) for the programming language [[Java (programming language)|Java]].<ref name="Belapurkar|2005">{{cite journal |last=Belapurkar |first=Abhijit |date=21 June 2005 |title=CSP for Java programmers |url=http://www.ibm.com/developerworks/library/j-csp1/ |journal=IBM DeveloperWorks |access-date=2007-04-20}}</ref>

Although CSP is a mathematical system, JCSP does not require in-depth mathematical skill, allowing instead that programmers can achieve well-behaved software by following simple rules.

==Overview==
There are four ways in which multi-threaded programs can fail untestably:<ref name="Belapurkar|2005"/>
*''[[Race condition]]s'' – shared variables may have indeterminate state because several threads access them concurrently without sufficient locking
*''[[Deadlock (computer science)|Deadlock]]'' – two or more threads reach a stalemate when they try to acquire locks or other resources in a conflicting way
*''[[Livelock]]'' – similar to deadlock but resulting in endless waste of CPU time
*''Starvation'' – one or more threads do no work, compromising the intended outcome of the software algorithms

Generally, it is not possible to prove the absence of these four hazards merely by rigorous testing. Although rigorous testing is necessary, it is not sufficient. Instead it is necessary to have a design that can demonstrate these four hazards don't exist. CSP allows this to be done using mathematics and JCSP allows it to be done pragmatically in Java programs.

The benefit of the basis in mathematics is that stronger guarantees of correct behaviour can be produced than would be possible with conventional ''ad hoc'' development. Fortunately, JCSP does not force its users to adopt a mathematical approach themselves, but allows them to benefit from the mathematics that underpins the library.

Note that the CSP term ''process'' is used essentially as a synonym for ''thread'' in Java parlance; a ''process'' in CSP is a lightweight unit of execution that interacts with the outside world via events and is an active component that encapsulates the data structures on which it operates.

Because the encapsulation of data is per-thread (per ''process'' in CSP parlance), there is typically no reliance on sharing data between threads. Instead, the coupling between threads happens via well-defined communication points and rendezvous. The benefit is that each thread can broadly be considered to be a "single-threaded" entity during its design, sparing the developer from the uncertainties of whether and where to use Java's ''synchronized'' keyword, and at the same time guaranteeing freedom from race conditions. JCSP provides for clear principles for designing the inter-thread communication in a way that is provably free from deadlock.

There is a clear similarity between some classes in the standard Java API ({{mono|java.util.concurrent}}) and some in JCSP. JCSP's ''channel'' classes are similar to the ''BlockingQueue''. There is one important difference: JCSP also provides an {{mono|Alternative}} class to allow selection between inputs; this capability is absent from the standard Java API. Alternation is one of the core concepts that CSP uses to model events in the real world.

{{mono|Alternative}} was proven to operate correctly by exhaustive mathematical analysis of its state space, guaranteeing it can never in itself cause a deadlock.<ref name="Welch|2000">{{cite report |last1=Welch |first1=Peter |last2=Martin |first2=Jeremy |year=2000 |title=Formal Analysis of Concurrent Java Systems |url=http://www.wotug.org/paperdb/send_file.php?num=44 |work=Communicating Process Architectures 2000}}</ref> As such, it epitomises the dependability of JCSP from its mathematical basis.

==Networking Layer==
Because [[Transmission Control Protocol]] (TCP) sockets can be constructed to behave as blocking channels in the CSP sense, it is possible to distribute JCSP processes across multiple computers. This is achieved using the JCSP Net extension that provides channels with CSP semantics using TCP. Because CSP is compositional, it does not matter in behaviour terms whether processes are co-located or distributed. The only difference is in the relative performance. So it is possible, for example, to develop an application on a single server then compare multi-processor version of the same application with the aim of optimising the performance.

==Other versions ==
===Robot edition===
JCSP re is a highly reduced version of the JCSP packages developed around 2008 at the [[Napier University]] Edinburgh by Professor Jon Kerridge, Alex Panayotopoulos and Patrick Lismore.  Research into JCSP for robotics environments and JCSP for mobile environments is an active area of research at Napier University Edinburgh.  The working implementation of 'JCSP re' allows the development of the same concurrent software for robots. Specifically, the robots targeted for this research were the [[Lego Mindstorms NXT]]s because they can run the popular [[LeJOS]] NXJ virtual machine that executes Java source code.<ref>{{Cite book |year=2008 |doi=10.3233/978-1-58603-907-3-255 |publisher=IOS Press Books |chapter-url=http://www.patricklismore.com/LinkClick.aspx?fileticket=SPV2uxPASHo%3D&tabid=78 |url-status=bot: unknown |archive-url=https://web.archive.org/web/20100418184718/http://www.patricklismore.com/LinkClick.aspx?fileticket=SPV2uxPASHo%3D&tabid=78 |archive-date=2010-04-18 |chapter=JCSPre: The Robot Edition to Control LEGO NXT Robots |title=Communicating Process Architectures 2008 |series=Concurrent Systems Engineering Series |last1=Kerridge Jon |last2=Panayotopoulos Alex |last3=Lismore Patrick }}</ref>

==Using JCSP from other languages==
JCSP is essentially a pure-Java API (although a research alternative exists that uses the [[C-CSP]] extension to the JVM). As such, it is in principle eminently suitable for concurrency in [[Scala (programming language)|Scala]] and [[Groovy (programming language)|Groovy]] applications as well as Java ones.

JCSP can therefore provide an alternative to Scala's [[actor model]]. JCSP uses synchronised communication and actors use buffered (asynchronous) communication, each of which have their advantages in certain circumstances. JCSP allows its channels to be buffered so can easily emulate the actor model; the converse is not true.

==See also==
*[[Communicating sequential processes]], the mathematics underlying JCSP

==References==
{{Reflist}}

==External links==
*[http://www.cs.kent.ac.uk/projects/ofa/jcsp/ JCSP project] at the University of Kent
*[http://www.patricklismore.com/jcspre/ JCSP re]{{dead link|date=December 2017 |bot=InternetArchiveBot |fix-attempted=yes}} early beta release

{{DEFAULTSORT:Jcsp}}
[[Category:Java platform software]]
[[Category:Concurrent computing]]