Join Java

 

Concurrency expression in most popular programming languages is still quite low level and based on constructs such as semaphores and monitors, that have not changed in twenty years. Libraries that are emerging (such as the upcoming Java concurrency library JSR-166) show that programmers are demanding higher-level concurrency semantics be available in mainstream languages and major new research results have emerged more recently in concurrency. Communicating Sequential Processes (CSP), Calculus of Communicating Systems (CCS) and Pi have higher-level synchronization behaviours defined implicitly through the composition of events at the interfaces of concurrent processes. Join calculus, on the other hand has explicit synchronization based on a localized conjunction of events defined as reduction rules. The Join semantics appear to be more appropriate to mainstream programmers; who want explicit expressions of synchronization that do not breach the Object Oriented idea of modularisation. Join readily expresses the dynamic creation and destruction of processes and channels which is sympathetic to dynamic languages like Java.

The research described here investigates if the Object Oriented programming language Java can be modified so that all expressions of concurrency and synchronization can use higher-level syntax and semantics inspired by the Join calculus. Of particular interest is to determine if a true integration can be made of Join into Java. This works seeks to develop a true language extension not just a class library. This research also investigates the impact of the Join constructs on the programming of well-known concurrency software patterns including the size and complexity of the programs. Finally, the impact on the performance on programs written in the language extension is also studied.

The major contribution of the thesis is the design of a new superset of Java called Join Java and the construction and evaluation of the first prototype compiler for the language. The Join Java language can express virtually all published concurrency patterns without explicit recourse to low-level monitor calls. In general, Join Java programs are more concise than their Java equivalents. The overhead introduced in Join Java by the higher-level expressions derived from the Join calculus is manageable. The synchronization expressions associated with monitors (wait and notify) which are normally located in the body of methods can be replaced by Join Java expressions (the Join patterns) which form part of the method signature. This provides opportunities in the future to enhance further the inheritance possibilities of Join Java possibly minimizing the impact of inheritance anomalies.

Publications


von Itzstein, G. Stewart. Introduction of High Level Concurrency Semantics in Object Oriented Languages, PhD Thesis Submitted January 5 2005
PDF Html

von Itzstein, G., Stewart and M. Jasiunas (2003). On Implementing High Level Concurrency in Java. Advances in Computer Systems Architecture 2003, Aizu Japan, Springer Verlag.
pdf - Slides

von Itzstein, G. Stewart. and D. Kearney (2002). Applications of Join Java. Proceedings of the Seventh Asia Pacific Computer Systems Architecture Conference ACSAC'2002. Melbourne, Australia, Australian Computer Society: 1-20.
pdf - Slides

Hopf, J., von Itzstein, G. Stewart. et al. (2002). Hardware Join Java: A High Level Language For Reconfigurable Hardware Development. International Conference on Field Programmable Technology, Hong Kong.
Available from first author

von Itzstein, G. Stewart. and Kearney, David (2001). Join Java: An Alternative Concurrency Semantic for Java, University of South Australia Technical Report ACRC-01-001.
offline - Slides

von Itzstein, G., Stewart (2000). Implementation of Join Semantics in Java :slides, University of South Australia, Advanced Computing Research Center.
Slides