INTRODUCTION OF HIGH LEVEL CONCURRENCY SEMANTICS IN OBJECT ORIENTED LANGUAGES By G Stewart von Itzstein Bachelor of Computer and Information Science (Honours) A thesis submitted for the Degree of Doctor of Philosophy 31st December 2004 Adelaide South Australia Reconfigurable Computing Laboratory http://rcl.unisa.edu.au School of Computing and Information Science University of South Australia http://www.vonitzstein.com/research TABLE OF CONTENTS 1 INTRODUCTION............................................................................................1 1.1 INTRODUCTION................................................................................................................. 2 1.2 MOTIVATION.................................................................................................................... 3 1.3 STRUCTURE OF THESIS..................................................................................................... 7 1.4 RESEARCH CONTRIBUTION .............................................................................................. 8 2 LITERATURE REVIEW ...............................................................................9 2.1 INTRODUCTION............................................................................................................... 10 2.2 ABSTRACTIONS OF CONCURRENCY ............................................................................... 11 2.2.1 Abstraction ............................................................................................................................................11 2.2.2 The Hierarchy of Abstractions of Concurrency...................................................................................12 2.3 PROCESS CALCULI AND THE JOIN CALCULUS................................................................ 17 2.3.1 Introduction...........................................................................................................................................17 2.3.2 Join Calculus.........................................................................................................................................18 2.3.3 Join Syntax ............................................................................................................................................18 2.3.4 Join Semantics.......................................................................................................................................19 2.3.5 Synchronous Names..............................................................................................................................20 2.3.6 Join Calculus vs. Other Calculi............................................................................................................21 2.3.7 Summary................................................................................................................................................21 2.4 THE OBJECT ORIENTED PARADIGM ............................................................................... 22 2.4.1 Advantages of the Object Oriented Paradigms....................................................................................24 2.4.2 History of Object Oriented Languages ................................................................................................25 2.4.3 Summary................................................................................................................................................26 2.5 CONCURRENT OBJECT ORIENTED LANGUAGES............................................................. 27 2.5.1 Actor versus Non-Actor Based Concurrent Languages.......................................................................29 2.5.2 Integrating Concurrency into Object Oriented Languages.................................................................30 2.5.3 Defining Mainstream Languages .........................................................................................................31 2.5.4 Implementing Concurrent Object Oriented Languages and Extensions.............................................32 2.5.5 Categorization of Concurrent Object Oriented Languages ................................................................37 2.5.6 Intra-Process Communications ............................................................................................................41 2.6 RELATED WORK ............................................................................................................ 43 2.6.1 Similarities between Join Java and Polyphonic C#.............................................................................43 2.6.2 Differences between Join Java and Polyphonic C#.............................................................................43 2.6.3 Summary................................................................................................................................................45 2.7 CONCLUSION.................................................................................................................. 46 3 JOIN JAVA SYNTAX AND SEMANTICS................................................47 3.1 INTRODUCTION............................................................................................................... 48 3.2 JAVA LANGUAGE SEMANTICS AND ITS DEFICIENCIES ................................................... 49 3.2.1 Java Concurrency .................................................................................................................................49 3.2.2 Synchronization.....................................................................................................................................51 3.2.3 Wait/Notify ............................................................................................................................................53 3.3 PRINCIPLES FOR IMPROVING JAVA CONCURRENCY SEMANTICS ................................... 55 3.3.1 High-Level Requirements .....................................................................................................................55 3.3.2 Extension Decisions in Intra-Process Communications......................................................................57 3.3.3 Concurrency Semantic Choice .............................................................................................................57 3.4 JOIN JAVA LANGUAGE SEMANTICS................................................................................ 59 3.4.1 Changes to the Language .....................................................................................................................59 3.4.2 Type System...........................................................................................................................................63 3.4.3 Relation between Join Java and Java ..................................................................................................63 3.4.4 Summary................................................................................................................................................67 ii 3.5 CONCLUSION.................................................................................................................. 68 4 IMPLEMENTATION ...................................................................................69 4.1 INTRODUCTION............................................................................................................... 70 4.2 COMPILER CHOICE ......................................................................................................... 71 4.3 TRANSLATOR ................................................................................................................. 72 4.3.1 The Extensible Compiler Architecture .................................................................................................72 4.3.2 Changes to the Extensible Compiler for Join Java..............................................................................78 4.4 PATTERN MATCHER....................................................................................................... 98 4.4.1 Application Programmer Interface for the Pattern Matcher...............................................................98 4.4.2 Approaches to Pattern Matching........................................................................................................102 4.4.3 Summary..............................................................................................................................................108 4.5 ISSUES IDENTIFIED IN THE PROTOTYPE........................................................................ 109 4.5.1 Multi-Directional Channels................................................................................................................109 4.5.2 Lock Parameter Association...............................................................................................................110 4.6 CONCLUSION................................................................................................................ 111 5 DESIGN PATTERNS..................................................................................113 5.1 INTRODUCTION............................................................................................................. 114 5.2 PATTERNS FOR SYNCHRONIZATION ............................................................................. 115 5.2.1 Scoped Locking ...................................................................................................................................115