Home > Store

JavaSpaces Example by Example

Register your product to gain access to bonus material or receive a coupon.

JavaSpaces Example by Example


  • Sorry, this book is no longer in print.
Not for Sale


  • Copyright 2002
  • Dimensions: K
  • Pages: 288
  • Edition: 1st
  • Book
  • ISBN-10: 0-13-061916-7
  • ISBN-13: 978-0-13-061916-7

  • The hands-on, example-rich guide to JavaSpaces technology
  • Building robust, scalable, high-performance distributed applications
  • Up-to-the-minute coverage based on Jini 1.1 network technology and JDK 1.4 software
  • Practical solutions to the most common challenges of distributed development

The example-rich guide to JavaSpaces technology: building more robust, scalable, and secure distributed applications for working developers!

JavaSpaces technology simplifies distributed computing, by providing a shared virtual space where tasks, requests, and information can easily be exchanged in the form of objects based on Javatm technology. JavaSpaces Example by Example offers an example-rich introduction to JavaSpaces architecture and its Jini network technology-based interfaces. Using this book's extensive examples and projects, experienced developers can begin building applications using the JavaSpaces specification almost immediately—and quickly master advanced techniques for enhancing security, performance, and scalability.

Steven L. Halter begins by introducing JavaSpaces technology: its goals, advantages, applications, and current capabilities. He walks you through obtaining, installing, and configuring JavaSpaces architecture, addressing common problems such as authorization configuration and improper codebase settings. Next, he introduces the fundamental concepts of development, including entries, leasing, events, transactions, and persistence.

You'll learn powerful distributed programming techniques, including the effective use of data structures and collections; and better ways to improve performance, prevent deadlock, and take full advantage of parallelism. Halter provides in-depth coverage of scalability and availability, concluding with detailed guidance on using security features based on Java 2 technology to protect distributed JavaSpaces applications.

Extensive code examples illustrate:

  • Leasing and events
  • Transactions and persistence
  • Jini technology interfaces
  • Performance optimization
  • Data structures
  • Collections
  • Preventing deadlock
  • Maximizing parallelism
  • Distributed application security
  • Improving scalability

Sample Content

Online Sample Chapter

Why Should You Be Using JavaSpaces?

Table of Contents



1. About JavaSpaces.

What Is a JavaSpace? JavaSpace Interface. Jini and JavaSpaces. Shared Distributed Computing. Persistent Object Repository. Uses of JavaSpaces. Information Sharing. Compute Serving. Work Flow. What's Next.

2. Obtaining and Installing JavaSpaces.

Getting Java Installed. Getting and Installing Jini. Sun Community Source License (SCSL). Getting Jini. Installing Jini. Getting a JavaSpace Running. Starting the Supporting Services. Starting with the GUI. Starting from the Command Line. Running the Ray-Tracing Example. What's Next.

3. JavaSpaces Basics.

Coding Conventions. Finding a JavaSpace. Compiling. Running the Services. Running the Example. Entries. Writing an Entry. Compiling. Running the Example. Reading an Entry. Entry Templates. Compiling. Running the Example. Taking an Entry. Compiling. Running the Example. The Snapshot Method. What's Next.

4. More JavaSpaces.

Leasing. Using Leases with JavaSpaces. Compiling. Running the Example. Using Transactions with JavaSpaces. Creating a Transaction. Transactions and JavaSpace Methods. Using Transactions with JavaSpaces. Distributed Events. Distributed Events and JavaSpaces. Event Example. Persistence. What's Next.


5. Encouraging Distribution.

Distributed Concepts. Parallelism. Partial Failure. Communication/Synchronization. Distributed Structures. Arrays. Compiling. Running the Example. Queues. Unordered Structures. What's Next.

6. Synchronization Issues.

Types of Synchronization Problems. Data Corruption. Deadlock Problems. Starvation Problems7. Synchronization Methodologies. Basic JavaSpace Mechanisms. Space Initialization. Semaphores. The Music Store Example. Compiling. To compile the classes for the synchronization example in Windows, use the following. What's Next.

7. Fairly Sharing Resources.

Sharing Fairly. Order-Processing Example. Item Viewer. Compiling. Running the Example. What's Next.


8. Parallel Computing.

Parallel Computing in General. Splitting Tasks up. Piecing Together the Results. A Parallel Computing Framework. A Prime Number Counter Application. Compiling. Running the Example. Scaling Further. Scaling Further Still. What's Next.

9. Security Issues.

Security in General. Security Model. RMID Security. Policy Files. Service Policies. Client Policy Files. Signing Files. JavaSpaces Security.

10. Wrapping It up.

Useful Places for Information. Web Sites. Mailing Lists. Other Technologies of Interest.




Writing distributed programs is hard. This should not be a surprising statement to anyone who has had to deal with a distributed programming environment in the past. The good news is that every year it is getting a little bit easier as programming technologies and tools gradually catch up to the needs of a distributed environment. In particular, the introduction of JavaSpaces technology simplifies the distributed computing environment in several ways.

JavaSpaces technology is a simple mechanism for performing distributed computing. In a distributed application, JavaSpaces provides a shared virtual space that providers and requesters of objects can use to communicate easily. This allows for the simple exchange of tasks, requests, and information in the form of Java objects. JavaSpaces also provides the ability to create and store objects with persistence.

JavaSpaces is a Jini technology service. This means that developers working with JavaSpaces can also make use of the various Jini services, such as transactions and notification.

JavaSpaces provides these capabilities with a very simple interface. Effectively making use of the simple interface, however, requires a number of tools, both conceptual and practical. This book should provide a solid base with a coherent set of examples to lead people in the right directions for using JavaSpaces technology.

About This Book

The intended audience is for intermediate to advanced programmers wanting to learn about JavaSpaces. A working knowledge of Java is needed, and an acquaintance with Jini concepts is very useful, but not required.

In this book, I have tried to give complete examples for each of the concepts that are being discussed.


In Part 1, "Getting to Know JavaSpaces," you look into the basics of using JavaSpaces. In Chapter 1, "About JavaSpaces" you explore what JavaSpaces are, how this book deals with them, and why anyone would want to use them. On the "what" side, the JavaSpace interface is presented along with some definitions of what the interfaces are. On the "why" side, the chapter presents some high level descriptions of the uses of JavaSpaces that are fleshed out in later chapters. Examples include using JavaSpaces as a mechanism for decoupled communication, application structuring, and parallel computing.

In Chapter 2, "Obtaining and Installing JavaSpaces," you get JavaSpaces (and Jini itself) up and running. Doing this the first time can be a challenging experience. This chapter takes you through the process of installing Jini and JavaSpaces and running a simple application. In particular, some of the common problems, such as authorization configuration problems and improper codebase settings, are covered. Although an experienced Jini developer may skip this chapter, for beginners, this should be extremely valuable.

In Chapter 3, "JavaSpaces Basics," you start to explore actually using a JavaSpace and writing some simple programs. It covers a simple method of locating a single JavaSpace. You then look at what an Entry is and how it can be used. Each concept is presented in the context of simple examples at this point.

Chapter 4, "More JavaSpaces," will flesh out the more advanced topics of dealing with JavaSpaces. Again, each of the topics is covered in a simple example format. Later chapters make greater use of these. This chapter is intended to establish familiarity and building blocks for these topics.

In Part 2, "Distributed Programming," you look at how you can apply the basics that you learned in Part 1 into writing distributed applications. In Chapter 5, "Encouraging Distribution," you start to explore programming in a distributed environment. Distributed programming is different than programming within a single machine (process). This chapter covers some of the concepts involved with programming in a distributed environment. In particular, it uses the concept of a linked list to explore some of the differences between distributed and nondistributed data structures.

Chapter 6, "Preventing Deadlock," discusses mechanisms for allowing processes to avoid deadlock. This chapter covers locking and sharing issues and presents mechanisms, such as semaphores, for dealing with resource synchronization.

Chapter 7, "Sharing Fairly," presents a more complex application example that makes use of (and ties together) many of the topics covered in earlier chapters. The application presents a small ordering processing system. This will be used to illustrate the concepts of sharing data in a fair and reliable manner.

In Part 3, "Going to the Next Level," you look at how you can use the mechanisms you learned in Parts 1 and 2 and use these mechanisms to help meet demands that are needed to move into real world applications. Chapter 8, "Parallel Computing," looks into some of the areas where you can get into performance trouble and also some of the ways in which JavaSpaces can be an aid to performance. There are a number of ways to improve (or degrade) the performance of a distributed application. Some common techniques for doing this, such as how to decide what computations could benefit from being distributed and how to distribute data, are discussed in this chapter.

Chapter 9, "Security Issues," looks into some of the security issues around JavaSpaces. There is currently no standard Jini security model. That does not mean, however, that your application can have no security itself. This chapter shows you how some of the security features of Java can be currently used with JavaSpaces. Setting up policy files and using some simple protocols to aid in application level security are discussed.

Chapter 10, "Wrapping It up" ties up any loose ends. In it, you also briefly encounter some of the ways JavaSpaces are being used and might be used.


Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership