`
` 1
`
`SAMSUNG 1009
`
`1
`
`SAMSUNG 1009
`
`
`
`-»v°-wéivir-3-'-Ia-'.-..a-‘m-5-.4..-
`
`E /
`
`/
`
`The Jini“ Technology Series
`Lisa Friendly, Series Editor
`Ken Arnold, Technical Editor
`For more information see: http://java.sun.com/docslhooks/jinif
`
`This series, written by those who design, implement, and document the Jini” technology,
`shows how to use, deploy, and create Jini applications. Jini technology aims to erase the
`hardware/software distinction, to foster spontaneous networking among devices, and to
`make pervasive a service-based architecture. In doing so, the Jini architecture is radically
`changing the way we think about computing. Books in The Jini Technology Series are
`aimed at serious developers looking for accurate, insightful, thorough, and practical
`material on Jini technology.
`
`The Jini Technology Series web site contains detailed information on the Series,
`including existing and upcoming titles, updates, errata, sources, sample code, and
`other Series-related resources.
`
`Ken Arnold, Bryan O’Su1]ivan, Robert W. Scheifler, Jim Waldo, Ann Wollrath, The Jim“ Specification
`ISBN 0-201-61634-3
`
`Eric Freeman, Susanne Hupfer, and Ken Arnold, JavaS_paces“‘ Principles, Patterns, and Practice
`ISBN 0-201-30955-6
`
`2
`
`
`
`Ken Arnold
`
`Bryan O’Su11ivan
`Robert W. Scheifler
`Jim Waldo
`
`Ann Wollrath
`
`A7
`
`7
`ADDISON-WESLEY
`
`An imprint of Addison Wesley Longman, Inc.
`Reading, Massachuseus - Harlow, England - Menlo Park, California
`Berknley, California - Don Mills, Ontario - Sydney
`Bonn 0 Amsterdam 0 Tokyo - Mexico City
`
`'
`
`3
`
`
`
`This book is dedicated to the Jini team
`
`without whom this book
`
`would not have been necessary
`
`4
`
`
`
`Contents
`
`Foreword .
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`. xvii
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`. xix
`
`Preface .
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`. . . . .
`
`.
`
`.
`
`.
`
`.
`
`.
`
`1» A R T 1
`
`Overview and Examples
`
`The Jini Architecture: An Introduction .
`
`.
`
`.
`
`1
`
`.
`.
`.
`.
`.
`.
`. .
`Overview .
`. . .
`.
`.
`.
`1.1 -
`Goals .
`1.2
`Architecture .
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`. .
`. .
`.
`.
`. . .
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`. . .
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`. . .
`
`1.3
`1.4
`1.5
`
`What the Jini Architecture Depends Upon .
`TheValueofaProxy.....‘ .
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`The Lookup Service .
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`1.5.1
`Attributes .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`
`.
`
`.
`
`. .
`.
`.
`. .
`
`. .
`.
`. . .
`. .
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`
`.
`
`.
`.
`._.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`. .
`.
`. . .
`
`.
`
`.
`.
`.
`
`. 3
`
`. 3
`. 4
`. 5
`
`.
`.
`.
`.
`.
`.
`. .
`
`. 7
`.
`.
`.
`. ..7
`.
`.
`.
`. 9
`.
`. .
`. 10
`
`1.5.2
`1.5.3
`1.5.4
`
`1.6
`1.7
`
`.
`.
`
`. 11
`. 12
`
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`Membership Management
`. .
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`Lookup Groups .
`.
`.
`.
`.
`.
`.
`.
`Lookup Service Compared to Naming/Directory
`Services
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .. .' .
`.
`.
`. . .. 13
`.
`Conclusion .
`.
`.
`. .
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 14-
`Notes on the Example Code .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 16
`1.7.1
`Package Structure .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`. . . 16
`Writing a Client .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 19
`2.1
`The Messagestream Interface .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 19
`2.2
`The Client
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . 20
`2.3
`In Conclusion .
`.
`.
`_
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . 27
`
`5
`
`
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`Writing a Service .
`3.1
`.
`.
`.
`.
`.
`.
`.
`.
`.
`Good Lookup Citizenship .
`3.1.1
`The Joi nhflanager Utility .
`The Fortunest ream Service .
`.
`.
`.
`.
`.
`.
`
`3.2
`
`.
`.
`.
`.
`
`.
`.
`. .
`.
`.
`.
`.
`
`.
`The Implementation Design .
`3.2.1
`Creating the Service .
`.
`.
`.
`.
`.
`.
`. .
`3.2.2
`The Running Service .
`.
`.
`.
`.
`.
`.
`.
`3.2.3
`The Chatstream Service .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`3.3.1
`“Service” versus “Server” .
`.
`.
`.
`
`Creating the Service .
`The Chat Server .
`.
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`
`3.3.2
`3.3.3
`
`3.3.4
`3.3.5
`3.3.6
`
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`. . .
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`._
`
`.
`.
`
`.
`.
`
`.
`
`.
`
`.
`
`.
`.
`
`.
`.
`.
`
`.
`
`.
`.
`
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`.
`. .
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`. . .
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`
`. . .
`.
`.
`.
`
`.
`.
`.
`
`.
`
`.
`.
`.
`
`.
`
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`_.
`.
`. .
`.
`.
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`
`.
`
`.
`.
`
`.
`.
`.
`
`.
`
`. 29
`. 29
`. 30
`. 30
`
`. 32
`. 32
`. 34
`. 37
`. 41
`
`. 41
`. 43
`
`. 50
`. 51
`. 52
`
`. 57
`
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`Implementing nextInL1' ne .
`Notes on Improving ChatServer'Imp'|
`The Clients .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`
`.
`
`.
`
`.
`
`.
`
`The Rest of This Book .
`
`.
`
`.
`
`. .
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`PART 2
`
`The Jini Specification
`
`. 61
`AR The Jini Architecture Specification ................... .
`AR.1 Introduction .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .. 61
`AR.1.1 Goals of the System .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`. 61
`AR.1_2 Environmental Assumptions . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .. 63
`System Overview .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`. 65
`AR.2.1
`Key Concepts .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .. 65
`AR.2.1.1 Services . .
`.
`.
`.
`. . . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`. .. 65
`
`AR.2
`
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`AR.2.1.2 Lookup Service .
`A.R.2.1.3 Java Remote Method Invocation (RMI)
`.
`AR.2.1.4 Security .
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`AR.2.1.5 Leasing .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`AR.2.l.6 Transactions .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`AR.2.1.7 Events
`. .
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`
`.
`.
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`
`. .
`.
`.
`
`. .
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`. .. 66
`. .. 66
`. .. 67
`. .. 67
`. .. 67
`. .. 67
`
`.. 68
`69
`
`. .. 69
`. .. 71
`. .. 72
`
`. .. 72
`. ..
`'75
`. .. 7'7
`.
`.
`. 77
`.
`.
`. 77
`
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`.
`Component Overview .
`AR.2.2.1 Infrastructure . .
`
`.
`.
`
`.
`.
`
`.
`.
`
`. . .
`.
`.
`.
`
`.
`.
`
`. . .
`.
`.
`.
`
`.
`.
`. .
`
`.
`.
`
`AR.2.2.2 Programming Model
`AR.2.2.3 Services .
`. .
`.
`.
`.
`.
`.
`.
`Service Architecture .
`.
`. .
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`.
`.
`.
`. . .
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`. . .
`
`AR.2.3
`
`.
`.
`
`.
`.
`.
`
`AR.2.3.1 Discovery and Lookup Protocols
`.
`AR.2.3.2 Service Implementation .
`.
`.
`.
`.
`.
`.
`.
`An Example .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`AR.3.1 Registering the Printer Service .
`.
`.
`.
`.
`.
`.
`.
`. . .
`AR.3.1.1 Discovering the Lookup Service .
`
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`
`. .
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`. ..'. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`
`6
`
`
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`AR.3.l.2 Joining the Lookup Service .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`AR.3.l.3 Optional Configuration .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`AR.3.1.4 Staying Alive .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`Printing .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`AR.3.2.l Locate the Lookup Service .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`_
`AR.3.2.2 Search for Printing Services .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`AR.3.2.3 Configuring the Printer .
`.
`.
`.
`.
`AR.3.2.4 Requesting That the Image Be Printed .
`.
`AR.3.2.5 Registering for Notification .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`AR.3.2.6 Receiving Notification .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`AR.4 For More Information .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`. 77
`.
`. 78
`.
`. 78
`.
`. 78
`.
`. 78
`.
`. 79
`.
`. 79
`.
`. 79
`.
`. 80
`.
`. 80
`.
`. .81
`
`DJ The Jini Discovery and Join Specification .
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`. .. 83
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.'
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`DJ.1 Introduction .
`DJ.1.1
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`Tenniuology .
`DJ.1.2
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`. .
`.
`Host Requirements
`DJ’.1.2.1 Protocol Stack Requirements for[P Networks. .
`Protocol Overview .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`
`DJ.1.3
`DJ.1.4
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`Discovery in Brief .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`DI.l.4.1 Groups . .
`.
`.
`.
`.
`DJ.1.4.2 The Multicast Request Pmtocol .
`DI.1.4.3 The Multicast Announcement Protocol
`
`DJ.1.5
`
`DJ .1.4.4 The Unicast Discovery Protocol .
`Dependencies .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`. .
`
`.
`.
`.
`.
`.
`
`. .83
`.
`. 83
`.
`. 84
`.
`. 84
`.
`. 85
`
`. 85
`.
`.
`. .. 85
`.
`.
`. 86
`.
`.
`. 87
`
`. 88
`.
`.
`. .. 88
`
`.
`.
`
`.
`.
`
`. 89
`. 89
`
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`.
`. .
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`. . .
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`
`.
`.
`
`The Discovery Protocols .
`DJ.2.1
`Protocol Roles .
`.
`.
`.
`.
`.
`.
`DJ 2.2
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`.
`. . .
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`The Multicast Request Protocol
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`DJ.2.2.l Protocol Participants .
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`DJ .2.2.2 The Multicast Request Service .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`DJ 2.2.3 Request Packet Format .
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`DJ 2.2.4 The Multicast Response Service .
`.
`.
`.
`.
`.
`.
`.
`.
`Discovery Using the Multicast Request Protocol
`.
`.
`.
`.
`.
`DJ 2.3.1 Steps Taken by the Discovering Entity .
`DJ 2.3.2 Steps Taken by the Multicast Request Server .
`DJ.2.3.3 Handling Responses from Multiple Djinns .
`.
`.
`The Multicast Announcement Protocol .
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`DJ.2.4.1 The Multicast Announcement Service .
`.
`.
`.
`.
`.
`.
`DJ 2.4.2 The Protocol .
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`Unicast Discovery .
`.
`.
`DJ.2.5.l The Protocol .
`DJ.2.5.2 Request Format .
`DJ 2.5.3 Response Format
`
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`. .
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`. .
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`. .
`. .
`
`.
`.
`.
`.
`
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`. . . 89
`.
`.
`. 89
`.
`.
`. 90
`.
`.
`. 91
`.
`. . 93
`.
`.
`. 93
`.
`.
`. 93
`.
`.
`. 94
`.
`.
`. 95
`.
`.
`. 95
`.
`.
`. 95
`.
`. . 97
`
`.
`.
`.
`.
`
`. 97
`.
`. 98
`.
`. 99
`.
`. 100
`
`7
`
`
`
`DJ.3
`
`.
`.
`The Join Protocol
`DJ.3.1
`Persistent State .
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`
`.
`.
`
`.
`
`.
`.
`
`.
`
`.
`.
`
`.
`
`.
`.
`
`.
`
`.
`.
`
`.
`
`.
`.
`
`.
`
`.
`.
`
`,
`
`.
`,
`
`.
`
`.
`.
`
`.
`
`. . .
`.
`.
`.
`
`.
`
`.
`
`.
`
`.
`.
`
`.
`
`.
`.
`
`.
`
`.
`.
`
`.
`
`.
`.
`.
`. . .
`
`.
`.
`. .
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`.
`
`.
`
`.
`.
`
`.
`
`.
`.
`
`.
`
`. .
`. .
`
`.
`.
`
`.
`.
`
`. 101
`. 101
`
`.
`
`.
`
`. .. 101
`
`DI.3.2 The Join Protocol
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`. .
`Initial Discovery and Registration . . .
`DJ3.2.1
`DJ3.2.2 Lease Renewal and Handling of Communication
`
`. 102
`
`DJ 3.2.3 Making Changes and Performing Updates .
`DJ3.2.4 Joining or Leaving a Group .
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`Network Issues .
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`
`.
`.
`.
`
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`Limiting the Scope of Multicasts .
`. .
`.
`. . .
`.
`.
`.
`DJ.4.4 Using Mu1ticastIP as the Underlying Transport
`D].4.5 Address and Port Mappings for TCP and Multicast UDP . .
`
`.
`
`DJ.5
`
`.
`.
`.
`
`.
`.
`.
`
`. . .
`. . .
`. . .
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`. . .
`. . .
`. .
`
`. .. 107
`. .
`. 108
`. .. 109
`
`DI.4.1
`
`Properties of the Underlying Transport
`DJ.4.1.1 Limitations on Packet Sizes .
`
`.
`.
`
`.
`.
`
`.
`.
`
`.
`.
`
`. . .
`. . .
`
`.
`.
`
`Bridging Calls to the Discovery Request Service .
`
`.
`.
`
`.
`
`.
`.
`
`.
`
`. . .
`.
`.
`.
`
`.
`
`.
`
`.
`
`DJ.4.2
`DI.4.3
`
`.
`.
`.
`
`.
`.
`
`.
`
`. 103
`.
`.
`. 103
`.
`.
`. .. 105
`
`.
`.
`
`.
`.
`
`. 105
`. 105
`
`. .
`
`. 105
`
`. 106
`. 106
`. 106
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`LookupLocator Class .
`DJ.5.1
`Jini Technology URL Syntax .
`DI.5.2 Serialized Form .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`
`DU The Jini Discovery Utilities Specification .
`DU.1
`Introduction . . .
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`DU.1.1 Dependencies .
`
`. .
`
`. .
`
`.
`
`.
`
`.
`
`. .
`
`.
`
`.
`
`.
`
`.
`
`.
`
`DU.2
`
`.
`
`.
`.
`.
`
`.
`
`.
`.
`.
`
`.
`
`.
`.
`.
`
`.
`
`.
`.
`.
`
`.
`
`.
`.
`.
`
`. .
`
`.
`
`.
`
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`. .
`.
`.
`
`.
`.
`
`.
`
`.
`.
`.
`
`.
`.
`
`.
`
`.
`.
`.
`
`.
`.
`
`.
`
`.
`.
`.
`
`.
`.
`
`.
`
`.
`.
`.
`
`.
`.
`
`.
`
`.
`._
`.
`
`.
`.
`
`.
`
`.
`.
`.
`
`.
`.
`.
`. . .
`
`. . .
`
`.
`.
`.
`. . .
`.
`.
`.
`
`. .. 111
`.
`. .. 111
`
`.
`
`.
`.
`.
`
`. .. 111
`
`. .. 113
`. .
`.
`114-
`. .
`. 115
`
`.
`.
`.
`Multicast Discovery Utility .
`DU.2.1 The LookupD1' scovery Class .
`DU.2.2 Useful Constants .
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`DU.2.3 Changing the Set of Groups to Discover
`DU.2.4 The D1'scoveryEvent Class .
`.
`.
`.
`.
`. . .
`.
`DU.2.S The D1‘ s::overyL1'stener Interface .
`.
`.
`DU.2.6 Security and Multicast Discovery .
`. . .
`.
`DU.2.7 Serialized Forms .
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. _ .
`.
`
`Protocol Utilities .
`
`.
`
`. .
`
`. .
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`DU.3.1 Marshalling Multicast Requests .
`. . .
`.
`.
`.
`.
`.
`DU.3.2 Unmarshalling Multicast Requests . . .
`.
`.
`.
`.
`.
`.
`DU.3.3 Marshalling Multicast Announcements .
`.
`.
`.
`DU.3.4 Urnmarshalling Multicast Announcements . .
`.
`.
`.
`DU.3.5 Easy Access to Constants .
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`DU.3.6 Marshalling Unicast Discovery Requests .
`.
`.
`.
`.
`.
`DU.3.7 Unmarshalling Unicast Discovery Requests .
`.
`.
`.
`DU.3.8 Marshalling Unicast Discovery Responses .
`.
`DU.3.9 Unrnarshalling Unicast Discovery Responses .
`.
`
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`. . .
`
`. . .
`
`. . .
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`. . .
`
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`. .
`.
`.
`.
`.
`. .
`
`. 115
`. 116
`. 116
`. 117
`. 118
`
`_ _
`
`_ 119
`
`. 119
`. .
`. .. 120
`. .
`. 121
`. .
`. 122
`. .
`. 122
`.
`.
`. 123
`.
`.
`. 123
`. .
`. 124
`. .. 124
`
`8
`
`
`
`EN The Jini Entry Specification .
`
`. . .
`
`.
`.
`.
`.
`.
`.
`.
`EN.1 Entries and Templates .
`.
`.
`.
`.
`.
`.
`.
`EN.1.1 Operations .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`EN.1.2 Entry .
`.
`.
`.
`.
`.
`. .
`. .
`.
`.
`.
`.
`EN.1.3 Serializing Entry Objects .
`EN.].4 Unusab'|eEntr'yExcept1'on .
`EN.I.5 Templates and Matching .
`.
`.
`.
`EN.1.6 Serialized Form .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`
`EU The Jini Entry Utilities Specification .
`EU.l Entry Utilities .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`EU.1.1 Abstrac1:Entry .
`.
`.
`.
`. .
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`EU.1.2 Serialized Form .
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`. .. 127
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`
`. .
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`
`. . .
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .- .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`. .. 127
`.
`. .. 127
`.
`. .. 128
`.
`.
`.
`. 128
`.
`. .. 129
`.
`. .. 131
`.
`. .. 131
`
`. .. 133
`. .. 133
`.
`. .. 133
`.
`. .. 134
`
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`. . .
`
`.
`LE The Jini Distributed Leasing Specification .
`.
`LE.l
`Introduction .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`LE.l.1 Leasing and Distributed Systems
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`LE.l.2 Goals and Requirements .
`.
`.
`. . .
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`LE.1.3 Dependencies .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`Basic Leasing Interfaces . . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`LE.2.1 Characteristics of a Lease .
`. . .
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`LE.2.2 Basic Operations .
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`LE.2.3 Leasing and Time .
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`LE.2.4 Serialized Forms .
`. . .
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`Example Supporting Classes . .
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`LE.3.1 A Renewal Class .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`LE.3.2 A Renewal Service .
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`. .
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`. .. 137
`.
`.
`.
`. .. 137
`.
`.
`.
`. .
`.
`.
`. 137
`.
`.
`.
`.
`.
`.
`. 140
`.
`.
`.
`.
`.
`.
`. 140
`.
`.
`.
`.
`.
`. 141_
`.
`.
`. . .
`.
`.
`. 141
`.
`.
`.
`.
`.
`.
`. 142
`.
`.
`.
`.
`.
`.
`. 147
`.
`.
`.
`.
`.
`.
`. 143
`. . .
`.
`.
`. 149
`.
`.
`.
`.
`.
`.
`. I49
`.
`.
`.
`.
`.
`.
`. 151
`
`EV The Jini Distributed Event Specification ............ .. 155
`EV.1 Introduction .
`.
`. .
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`. 155
`EV.l.1 Distributed Events and Notifications . . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`. 155
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`EV.1.2. Goals and Requirements .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`EV.1.3 Dependencies .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`The Basic Interfaces .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`EV.2.1 Entities Involved .
`.
`.
`.
`.
`.
`.
`EV.2.2 Overview of the Interfaces and Classes .
`
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`. . .
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`EV.2.3 Details of the Interfaces and Classes ._.
`.
`.
`EV.2.3.1 The RemoteEventL'i stener Interface .
`.
`.
`EV_2.3.2 The Remo1:eEvent Class .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`EV.2.3.3 The UnknownEventExcept1'on .
`.
`.
`.
`.
`.
`EV.2.3.4 An Example Eventcenerator Interface .
`EV.2.3.5 The Even1:Reg'istra1:1' on Class
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`
`. 156
`.
`.
`. .. 157
`.
`. 159
`.
`.
`. 159
`.
`.
`. 161
`
`. 163
`.
`.
`. 163
`.
`.
`. .. 164
`.
`.
`. 165
`.
`.
`. 166
`.
`.
`. 168
`
`9
`
`
`
`.
`.
`.
`. .
`.
`.
`.
`EV.2.4 Sequence Numbers, Leasing and Transactions .
`. . .
`.
`.
`.
`.
`.
`EV.2.5 Serialized Forms .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`Third-Party Objects .
`.
`.
`.
`. _ .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`EV.3.l Store—and-Forward Agents . . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`EV.3.2 Notification Filters .
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`EV.3.2.l Notification Multiplexing .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`EV.3.2.2 Notification Demultiplexing .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`EV.3.3 Notification Mailboxes .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`EV.3.4 Compositionality .
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`EV.4 Integration with JavaBeans Components .
`.
`.
`EV.4.l Differences with the JavaBeans Component Event Model
`EVA-.2 Converting Distributed Events to IavaBeans Events .
`.
`.
`.
`
`. 169
`.
`.
`. .. 170
`.
`.
`. 171
`.
`.
`. 171
`. .. 173
`. .. 174
`.
`.
`. 174
`. .. 175
`.
`.
`. 176
`.
`.
`. 179
`.
`. 180
`.
`. 182
`
`.
`
`.
`.
`.
`
`. .. 185
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`TX The Jini Transaction Specification .
`.
`.
`.
`. 185
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`TX.1 Introduction .
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .. 186
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`TX.1.1 Model and Terms .
`.
`.
`.
`.
`.
`.
`.
`.
`. .._.
`.
`.
`.
`.
`. 188
`.
`.
`.
`.
`.
`.
`.
`TX.1.2 Distributed Transactions and ACID Properties
`.
`.
`.
`. 189
`.
`.
`.
`.
`.
`.
`.
`.
`TX.1.3 Requirements .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 190
`.
`.
`.
`.
`.
`.
`.
`'I'X.l.4 Dependencies .
`.
`. .
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`. . .
`.
`.
`.
`. 191
`.
`.
`.
`.
`.
`.
`.
`The Two-Phase Commit Protocol
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 192
`.
`.
`.
`.
`.
`.
`.
`.
`TX.2.1 Starting a Transaction .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 193
`.
`.
`.
`.
`.
`.
`.
`.
`TX.2.2 Starting a Nested Transaction .
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 195
`.
`.
`.
`.
`.
`.
`.
`.
`TX.2.3 Joining a Transaction .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 196
`.
`.
`.
`.
`.
`.
`.
`.
`TX.2.4 Transaction States . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 197
`.
`.
`.
`.
`.
`.
`.
`TX.2.5 Completing a Transaction: The C1ient’s View .
`.
`.
`.
`. 199
`.
`.
`.
`.
`TX.2.6 Completing a Transaction: A Participant's View . .
`.
`.
`.
`. 202
`.
`.
`.
`.
`TX.2.7 Completing a Transaction: The Manager's View .
`.
`.
`'.
`.
`. 204
`.
`.
`.
`.
`TX.2.8 Crash Recovery .
`. .
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 205
`.
`.
`.
`.
`TX.2.8.1 The Roll Decision .
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`. 205
`.
`.
`.
`.
`TX.2.9 Durability .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 207
`.
`.
`.
`.
`Default Transaction Semantics .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 207
`.
`TX.3.1 Transaction and Nestabl eTransact1'on Interfaces .
`.
`.
`.
`. 209
`.
`TX.3.2 Tr‘ansac1:1'onFac1:ory Class .
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`TX.3.3 Serve r'Transact'i on and Nestabl eSe We r'Transact1' on
`Classes
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`,
`.
`.
`.
`TX.3.4 CannotNestExcept1' on Class .
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`TX.3.5 Semantics .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`TX.3.6 Serialized Forms . . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`
`.
`.
`.
`.
`
`. 210
`. "212
`. 212
`. 214
`
`. 217
`LU The Jini Lookup Service Specification .............. .
`.
`. 217
`LU.1 Introduction .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`LU.1.1 The Lookup Service Model
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`. 217'
`LU.l.2 Attributes
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .. 218
`
`.
`
`10
`
`
`
`.
`.
`.
`.
`LU.1.3 Dependencies .
`The Ser'v'iceReg1'str'ar'
`LU.2.1 Servi ceID .. .
`.' .
`.
`.
`LU.2.2 Serviceltem .
`. .
`.
`.
`
`.
`
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`. .
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`. .
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`
`.
`.
`.
`.
`
`LU.2.3 Se rvi ceTemp'| ate and Item Matching .
`LU.2.4 Other Supporting Types .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`LU.2.5 Servi ceReg'i strar .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`LU.2.6 Servi ceReg'i strati on _
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`LU.2.7 Serialized Forms .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`
`.
`.
`.
`.
`. .
`. .
`
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`.
`.
`. .
`. .
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`. . _ .
`.
`.
`.
`
`. 219
`.
`.
`.
`. .. 221
`.
`. .. 221
`.
`. .. 222
`
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`
`. .
`. .
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`
`. 223
`.
`.
`. 224
`.
`.
`. 225
`. .
`. 229
`.
`.
`. .. 230
`
`The Jini Lookup Attribute Schema Specification .... 233
`LS.1 Introduction.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .. 233
`LS.l.1 Terminology .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 234
`LS.l.2 Design-Issues .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`. .
`. 234
`LS.l.3 Dependencies .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .. 235
`Human Access to Attributes .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 237
`
`. 237
`.
`.
`.
`.
`.
`.
`.
`.
`LS.2.1 Providing a Single View of an Att:ribute‘s Value .
`. 239
`.
`.
`.
`.
`.
`.
`.
`JavaBeans Components and Design Patterns .
`.
`. 239
`.
`.
`.
`.
`.
`.
`.
`LS.3.1 Allowing Display and Modification of Attributes .
`LS.3.l.1 Using .TavaBeans Components with Entry Classes 239
`LS.3.2 Associating JavaBeans Components with Entry Classes
`.
`.
`.
`. 240
`.
`LS.3.3 Supporting Interfaces and Classes .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. 241
`Generic Attribute Classes .
`.
`_
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`. 243
`
`.
`.
`Indicating User Modifiability .
`LS.4.1
`.
`.
`LS.4.2 Basic Service Information .
`.
`.
`.
`.
`.
`LS.4.3 More Specific Information .
`.
`.
`.
`.
`LS.4.4 Naming a Service .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`LS.4.5 Adding a Comment to a Service .
`LS.4.6 Physical Location .
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`LS.4.'.«' Status Information .
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`LS.4.8 Serialized Forms .
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`. .
`.
`.
`.
`.
`.
`. . .
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`,
`
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`._
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`
`. 243
`. 243
`. 245
`. 246
`. 246
`. 247
`. 248
`. 249
`
`JS The Javaspaces Specification ......................... .
`
`. 253
`
`JS.l
`
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`Introduction.
`JS.1.l
`The Javaspaces Application Model and Terms
`JS.1.1.1 Distributed Persistence .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`
`. . .
`.
`.
`_
`.
`.
`.
`
`.
`.
`.
`
`.
`.
`.
`
`JS.1.1.2 Distributed Algorithms as Flows of Objects
`JS.1.2 Benefits .
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`. .
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`Javaspaces Technology and Databases .
`JS.l.3
`Javaspaces System Design and Linda Systems
`JS.1.4
`JS.1.5 Goals and Requirements .
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`JS.l.6 Dependencies .
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`. . .
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`. .
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`. . .
`
`. 253
`.‘-
`. 253
`.
`. 254
`
`. . .
`.
`.
`.
`
`.
`.
`
`. 254
`. 256
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`.
`.
`.
`.
`
`. . 257
`.
`. 258
`.
`. 259
`.
`. 260
`
`11
`
`
`
`JS.2.3
`JS.2.4
`JS.2.5
`.lS.2.6
`JS.2.7
`
`JS.2 Operations .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`,
`JS.2.l
`Entries .
`.
`.
`.
`.
`.
`.
`.
`JS.2.2
`net.j1'n'i .space.'JavaSpace .
`JS.2.2.1
`Interna'|5paceExcept-ion .
`.
`write .
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`re-adIfEx1'sts and read .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`takeIfEx1' 51:5 and take . .
`.
`.
`.
`.
`.
`. . .
`.
`.
`snapshot
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`notify .
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`. .
`.
`.
`JS.2.8 Operation Ordering .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`JS.2.9
`Serialized Form .
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`Transactions .
`. _ .
`.
`.
`. .
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`JS.3.1 Operations under Transactions .
`.
`.
`.
`.
`.
`.
`.
`JS.3.2 Transactions and ACID Properties .
`.
`.
`.
`.
`Further Reading .
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`JS.4.1
`Linda Systems .
`. .
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`ISA-.2 The Java Platform .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`JS.4.3 Distributed Computing .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`. .
`.
`. . .
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`. 261
`.
`.
`.
`.
`.
`.
`.
`.
`. 261
`.
`.
`.
`.
`.
`.
`.
`.
`. 262
`.
`.
`.
`.
`.
`.
`.
`.
`. .. 263
`.
`.
`.
`.
`.
`.
`.
`.
`. 264
`.
`. .
`.
`.
`.
`.
`.
`. 264
`.
`.
`.
`.
`.
`.
`.
`.
`. 265
`.
`.
`.
`.
`.
`.
`.
`.
`. 265
`.
`.
`.
`.
`.
`.
`.
`.
`. 266
`.
`.
`.
`.
`.
`.
`.
`.
`. 268
`.
`. .
`.
`.
`.
`.
`.
`. 268
`.
`.
`.
`.
`.
`.
`.
`. 269
`.
`.
`.
`.
`.
`.
`.
`.
`. 269
`. .
`.
`.
`.
`.
`.
`.
`. 270
`. . .
`.
`.
`.
`.
`.
`. 273
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`. 273
`.
`.
`.
`.
`.
`.
`.
`.
`. 273
`.
`.
`.
`.
`.
`.
`.
`.
`. 274
`
`DA.2
`
`DA.2.4
`
`DA.2.S
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`.
`DA The Jini Device Architecture Specification .
`DA.1
`.
`.
`Introduction .
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`DA.1.l Requirements from the Jini Lookup Service .
`.
`.
`.
`Basic Device Architecture Examples .
`. . .
`.
`.
`.
`.
`. .
`DA.2.1 Devices with Resident Java Virtual Machines .
`.
`.
`DA.2.2 Devices Using Specialized Virtual Machines .
`.
`DA.2.3 Clustering Devices with a Shared Virtual Machine
`(Physical Option)
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`Clustering Devices with a Shared Virtual Machine
`.
`.
`.
`. .
`.
`(Network Option)
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`Jini Software Services over the Internet Inter—Operabi1ity
`Protocol . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`. .
`.
`.
`.
`.
`.
`.
`. .
`. .
`
`. .. 277
`.
`.
`. .. 277
`.
`.
`.
`.
`. 2'78
`.
`. . .
`.
`. 281
`.
`.
`.
`.
`. 281
`.
`. . .
`. 28
`'
`. 284
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`. 286
`
`.
`
`. 238
`
`PART 3
`
`Supplemental Material
`
`The Jini Technology Glossary .
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`. . .
`
`.
`
`.
`
`.
`
`. . .
`
`.
`
`. .
`
`.
`
`.
`
`.
`
`. .
`
`.
`
`.
`
`.
`
`. 293
`
`Appendix A: A Note on Distributed Computing .... ..' . .. 307
`A.1
`Introduction .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .. 307
`A. 1 .1
`Terminology .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`. .
`.
`.
`.
`.
`.
`.
`. 308
`
`12
`
`
`
`A.2
`A.3
`A.4
`
`A.5
`A.6
`A.7
`A3
`A3
`A.10
`All
`
`.
`.
`.
`. .
`The Vision of Unified Objects .
`.
`.
`.
`.
`.
`Déjii Vu All Over Again .
`.
`.
`.
`.
`.
`Local and Distributed Computing .
`A.4.1
`Latency .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`A.4.2 Memory Access .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`Partial Failure and Concurrency .
`.
`The Myth of “Quality of Service” .
`.
`Lessons From NFS .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`Taking the Difference Seriously .
`.
`.
`.
`A Middle Ground . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`References .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`Observations for this Reprinting .
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`. .
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`Appendix B: The Example Code .
`
`.
`
`. .
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`. . .
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. .
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`
`.
`
`.
`
`. . .
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`
`.
`
`.
`
`. 308
`.
`.
`. 311
`.
`.
`. .. 312
`.
`. .. 312
`.
`.
`.
`. 314
`.
`.
`. 316
`.
`.
`. 318
`.
`.
`. 320
`.
`.
`. 322
`.
`.
`. 324
`.
`.
`. 32.5
`. .
`. 326
`
`.
`
`.
`
`. 327
`
`. ..3’71
`
`Index .
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`Colophon .
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`_
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`.
`
`. .. 385
`
`13
`
`
`
`Foreword
`
`TIIE emergence of the Internet has led computing into a new era. It is no longer
`. what your computer can do that matters. Instead, your computer can have access
`to the power of everything that is connected to the network: The Network is the
`Computer“. This network of devices and services is the computing environment
`' of the future.
`The Java” programming language brought reliable object—oriented programs
`' to the net. The power of the Java platform is its simplicity, which allows program-
`..mers to be fully fluent in the language. This simplicity allows debugged Java pro-
`grams to be written in about a quarter the time it takes to write programs in C++.
`We believe that use of the Java platform is the key to the emergence of a “best
`practices" discipline in software construction to give us the reliability we need in
`our software systems as they become more and more widely used.
`The Jinim architecture is designed to bring reliability and simplicity to the
`construction of networked devices and services. The philosophy behind Jini is lan-
`guage-based systems: a Jini system is a collection of interacting Java programs,
`and you can understand the behavior of this Jini system completely by under-
`standing the semantics of the Java programrning language and the nature of the
`network, namely that networks have limited bandwidth, inherent latency, and par-
`tial failure.
`
`Because the Jini architecture focuses on a few simple principles, we can teach
`-- Java language programmers the full power of the Jim technology in a few days. To
`do this, we introduce remote objects (they just throw a RamoteExcept1' on), leas-
`ing (commitments in a Jini system are of limited duration), distributed events (in
`the network events aren’t as predictable on a single machine), and the need for
`two-phase commit (because the network is a world of partial failures). This small
`set of additional concepts allows distributed applications to be written, and we can
`- illustrate this with the JavaSpacesTM service, which is also specified here.
`For me, the Jim -architecture represents the results of almost 20 years of yearn-
`ing for a new substrate for distributed computing. Ever since I shipped the first
`
`14
`
`
`
`FOREWORD
`
`widely used implementation of TCP/IP with the Berkeley UNIX system, I have
`wanted to raise the level of discourse on the network from the bits and bytes of
`TCP/IP to the level of objects. Objects have the enormous advantage of combining
`the data with the code, greatly improving the reliability and integrity of systems.
`For me, the Jini architecture represents the culmination of this dream.
`I would like to thank the entire Jini team for their continuing hard work and
`commitment. I would especially like to thank my longtime collaborator Mike
`Clary for helping to get the Jini project started and for directing the project; the
`Jini architects Jim Waldo, Ken Arnold, Bob Scheiffler, and Ann Wollrath for
`designing and implementing such a simple and elegant system; Mark Hodapp for
`his excellent engineering management