`
`O REILLY*
`
`Seoll Oaks & Henry Wong
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`TRILLER EXHIBIT 1015-001
`
`

`

`Java Threads, 2nd edition
`
`
`
`Scott Oaks & Henry Wong
`
`
`2nd Edition January 1999
`ISBN: 1-56592-418-5, 332 pages
`
`
`
`Revised and expanded to cover Java 2, Java Threads shows you how to
`take full advantage of Java's thread facilities: where to use threads to
`increase efficiency, how to use them effectively, and how to avoid
`common mistakes.
`
`It thoroughly covers the Thread and ThreadGroup classes, the Runnable
`interface, and the language's synchronized operator.
`
`The book pays special attention to threading issues with Swing, as well
`as problems like deadlock, race condition, and starvation to help you
`write code without hidden bugs.
`
`
`
`
`
`
`
`
`
`
`TRILLER EXHIBIT 1015-002
`
`

`

`Table of Contents
`
`
`
`Preface
`
`1. Introduction to Threading
`
`Java Terms
`
`Thread Overview
`
`Why Threads?
`
`Summary
`
`2. The Java Threading API
`
`Threading Using the Thread Class
`
`Threading Using the Runnable Interface
`
`The Life Cycle of a Thread
`
`Thread Naming
`
`Thread Access
`
`More on Starting, Stopping, and Joining
`
`Summary
`
`3. Synchronization Techniques
`
`A Banking Example
`
`Reading Data Asynchronously
`
`A Class to Perform Synchronization
`
`The Synchronized Block
`
`Nested Locks
`
`Deadlock
`
`Return to the Banking Example
`
`Synchronizing Static Methods
`
`Summary
`
`4. Wait and Notify
`
`Back to Work (at the Bank)
`
`Wait and Notify
`
`wait(), notify(), and notifyAll()
`
`wait() and sleep()
`
`Thread Interruption
`
`Static Methods (Synchronization Details)
`
`Summary
`
`5. Useful Examples of Java Thread Programming
`
`Data Structures and Containers
`
`Simple Synchronization Examples
`
`A Network Server Class
`
`The AsyncInputStream Class
`
`Using TCPServer with AsyncInputStreams
`
`Summary
`
`6. Java Thread Scheduling
`
`An Overview of Thread Scheduling
`
`When Scheduling Is Important
`
`Scheduling with Thread Priorities
`
`Popular Scheduling Implementations
`
`Native Scheduling Support
`
`Other Thread-Scheduling Methods
`
`Summary
`
`
`
`
`1
`
`5
`
`12
`
`31
`
`
`
`50
`
`64
`
`87
`
`TRILLER EXHIBIT 1015-003
`
`

`

`Table of Contents (cont...)
`
`
`
`7. Java Thread Scheduling Examples
`
`Thread Pools
`
`Round-Robin Scheduling
`
`Job Scheduling
`
`Summary
`
`8. Advanced Synchronization Topics
`
`Synchronization Terms
`
`Preventing Deadlock
`
`Lock Starvation
`
`Thread-Unsafe Classes
`
`Summary
`
`9. Parallelizing for Multiprocessor Machines
`
`Parallelizing a Single-Threaded Program
`
`Inner-Loop Threading
`
`Loop Printing
`
`Multiprocessor Scaling
`
`Summary
`
`10. Thread Groups
`
`Thread Group Concepts
`
`Creating Thread Groups
`
`Thread Group Methods
`
`Manipulating Thread Groups
`
`Thread Groups, Threads, and Security
`
`Summary
`
`A. Miscellaneous Topics
`
`B. Exceptions and Errors
`
`Colophon
`
`
`
`117
`
`137
`
`162
`
`189
`
`203
`
`209
`
`214
`
`
`
`TRILLER EXHIBIT 1015-004
`
`

`

`Description
`Threads aren't a new idea: many operating systems and languages support them. But despite
`widespread support, threads tend to be something that everyone talks about, but few use.
`Programming with threads has a reputation for being tricky and nonportable.
`
`Not so with Java. Java's thread facilities are easy to use, and - like everything else in Java - are
`completely portable between platforms. And that's a good thing, because it's impossible to write
`anything but the simplest applet without encountering threads. If you want to work with Java, you
`have to learn about threads.
`
`This new edition shows you how to take full advantage of Java's thread facilities: where to use threads
`to increase efficiency, how to use them effectively, and how to avoid common mistakes.
`
`Java Threads discusses problems like deadlock, race condition, and starvation in detail, helping you
`to write code without hidden bugs. It brings you up to date with the latest changes in the thread
`interface for JDK 1.2.
`
`The book offers a thorough discussion of the Thread and ThreadGroup classes, the Runnable
`interface, the language's synchronized operator. It explains thread scheduling ends by developing a
`CPUSchedule class, showing you how to implement your own scheduling policy. In addition, Java
`Threads shows you how to extend Java's thread primitives. Other extended examples include classes
`that implement reader/writer locks, general locks, locks at arbitrary scope, and asynchronous I/O.
`This edition also adds extensive examples on thread pools, advanced synchronization technique, like
`condition variables, barriers, and daemon locks. It shows how to work with classes that are not thread
`safe, and pays special attention to threading issues with Swing. A new chapter shows you how to write
`parallel code for multiprocessor machines.
`
`In short, Java Threads covers everything you need to know about threads, from the simplest
`animation applet to the most complex applications. If you plan to do any serious work in Java, you will
`find this book invaluable. Examples available online. Covers Java 2.
`
`
`
`
`
`
`
`
`
`
`
`
`
`TRILLER EXHIBIT 1015-005
`
`

`

`Java Threads, 2nd edition
`
`
`Preface
`When Sun Microsystems released the first alpha version of Java™ in the winter of 1995, developers all
`over the world took notice. There were many features of Java that attracted these developers, not the
`least of which were the set of buzzwords Sun used to promote Java: Java was, among other things,
`robust, safe, architecture-neutral, portable, object oriented, simple, and multithreaded. For many
`developers, these last two buzzwords seemed contradictory: how could a language that is
`multithreaded be simple?
`
`It turns out that Java's threading system is simple, at least relative to other threading systems. This
`simplicity makes Java's threading system easy to learn, so that even developers who are unfamiliar
`with threads can pick up the basics of thread programming with relative ease. But this simplicity
`comes with trade-offs: some of the advanced features that are found in other threading systems are
`not present in Java. However, these features can be built by the Java developer from the simpler
`constructs Java provides. And that's the underlying theme of this book: how to use the threading tools
`in Java to perform the basic tasks of threaded programming, and how to extend them to perform more
`advanced tasks for more complex programs.
`
`Who Should Read This Book?
`
`This book is intended for programmers of all levels who need to learn to use threads within Java
`programs. The first few chapters of the book deal with the issues of threaded programming in Java,
`starting at a basic level: no assumption is made that the developer has had any experience in threaded
`programming. As the chapters progress, the material becomes more advanced, in terms of both the
`information presented and the experience of the developer that the material assumes. For developers
`who are new to threaded programming, this sequence should provide a natural progression of the
`topic.
`
`This progression mimics the development of Java itself as well as the development of books about
`Java. Early Java programs tended to be simple, though effective: an animated image of Duke dancing
`on a web page was a powerful advertisement of Java's potential, but it barely scratched the surface of
`that potential. Similarly, early books about Java tended to be complete overviews of Java with only a
`chapter or two dedicated to Java's threading system.
`
`This book belongs to the second wave of Java books: because it covers only a single topic, it has the
`luxury of explaining in deeper detail how Java's threads can be used. It's ideally suited to developers
`targeting the second wave of Java programs - more complex programs that fully exploit the power of
`Java's threading system.
`
`Though the material presented in this book does not assume any prior knowledge of threads, it does
`assume that the reader has a knowledge of other areas of the Java API and can write simple Java
`programs.
`
`Versions Used in This Book
`
`Writing a book on Java in the age of Internet time is hard: the sand on which we're standing is
`constantly shifting. But we've drawn a line in that sand, and the line we've drawn is at the JDK™ 2
`from Sun Microsystems. It's likely that versions of Java that postdate Java 2 will contain some
`changes to the threading system not discussed in this version of the book. We will also point out the
`differences between Java 2 and previous versions of Java as we go, so that developers who are using
`earlier releases of Java will also be able to use this book.
`
`Some vendors that provide Java - either embedded in browsers or as a development system - are
`contemplating releasing extensions to Java that provide additional functionality to Java's threading
`system (in much the same way as the examples we provide in Chapter 5 through Chapter 8 use the
`basic techniques of the Java threaded system to provide additional functionality). Those extensions
`are beyond the scope of this book: we're concerned only with the reference JDK 2 from Sun
`Microsystems. The only time we'll consider platform differences is in reference to an area of the
`reference JDK that differs on Unix platforms and Windows platforms: these platforms contain some
`differences in the scheduling of Java threads, a topic we'll address in Chapter 6.
`
` page 1
`
`TRILLER EXHIBIT 1015-006
`
`

`

`Java Threads, 2nd edition
`
`
`Organization of This Book
`
`Here's an outline of the book, showing the progression of the material we present. The material in the
`appendixes is generally either too immature to present fully or is mostly of academic interest,
`although it may be useful in rare cases.
`Chapter 1
`This chapter introduces the concept of threads and the terms we use in the book.
`Chapter 2
`This chapter introduces the Java API that allows the programmer to create threads.
`Chapter 3
`This chapter introduces the simple locking mechanism that Java developers can use to
`synchronize access to data and code.
`Chapter 4
`This chapter introduces the other Java mechanism that developers use to synchronize access
`to data and code.
`Chapter 5
`This chapter summarizes the techniques presented in the previous chapters. Unlike the earlier
`chapters, this chapter is solutions oriented: the examples give you an idea of how to put
`together the basic threading techniques that have been presented so far, and provide some
`insight into designing effectively using threads.
`Chapter 6
`This chapter introduces the Java API that controls how threads are scheduled by the virtual
`machine, including a discussion of scheduling differences between different implementations
`of the virtual machine.
`Chapter 7
`This chapter provides examples that extend Java's scheduling model, including techniques to
`provide round-robin scheduling and thread pooling.
`Chapter 8
`This chapter discusses various advanced topics related to data synchronization, including
`designing around deadlock and developing some additional synchronization classes, including
`synchronization methods from other platforms that are not directly available in Java.
`Chapter 9
`This chapter discusses how to design your program to take advantage of a machine with
`multiple processors.
`Chapter 10
`This chapter discusses Java's ThreadGroup class, which allows a developer to control and
`manipulate groups of threads. Java's security mechanism for threads is based on this class
`and is also discussed in this chapter.
`Appendix A
`This appendix presents a few methods of the Java API that are of limited interest: methods
`that deal with the thread's stack and the ThreadDeath class.
`Appendix B
`This appendix presents the details of the exceptions and errors that are used by the threading
`system.
`
` page 2
`
`TRILLER EXHIBIT 1015-007
`
`

`

`Java Threads, 2nd edition
`
`
`Conventions Used in This Book
`
`Constant width font is used for:
`• Code examples:
`public void main(String args[]) {
` System.out.println("Hello, world");
`}
`• Method, variable, and parameter names within the text, as well as keywords
`
`
`
`
`
`Bold constant width font is used for:
`• Presenting revised code examples as we work through a problem:
`public void main(String args[]) {
` System.out.println("Hello, world");
`}
`• Highlighting a section of code for discussion within a longer code example
`
`
`
`
`
`Italic font is used for URLs and filenames, and to introduce new terms.
`
`Examples of the programs in this book may be retrieved online from:
`http://www.oreilly.com/catalog/jthreads2
`
`
`Feedback for Authors
`
`We've attempted to be complete and accurate throughout this book. Changes in releases of the Java
`specification as well as differing vendor implementations across many platforms and underlying
`operating systems make it impossible to be completely accurate in all cases (not to mention the
`possibility of our having made a mistake somewhere along the line). This book is a work in progress,
`and as Java continues to evolve, so, too, will this book. Please let us know about any errors you find, as
`well as your suggestions for future editions, by writing to:
`O'Reilly & Associates, Inc.
`101 Morris Street
`Sebastopol, CA 95472
`1-800-998-9938 (in the U.S. or Canada)
`1-707-829-0515 (international/local)
`1-707-829-0104 (FAX)
`You can also send us messages electronically. To be put on the mailing list or request a catalog, send
`email to:
`http://safari2.oreilly.com/info@oreilly.com
`To ask technical questions or comment on the book, send email to:
`bookquestions@oreilly.com
`We have a web site for the book, where we'll list examples, errata, and any plans for future editions.
`You can access this page at:
`http://www.oreilly.com/catalog/jthreads2/
`For more information about this book and others, see the O'Reilly web site:
`http://www.oreilly.com/
`The authors welcome your feedback about this book, especially if you spot errors or omissions that we
`have made. You can contact us at scott.oaks@sun.com and henry.wong@sun.com.
`
` page 3
`
`TRILLER EXHIBIT 1015-008
`
`

`

`Java Threads, 2nd edition
`
`
`Acknowledgments
`
`As readers of prefaces are well aware, writing a book is never an effort undertaken solely by the
`authors who get all the credit on the cover. We are deeply indebted to the following people for their
`help and encouragement: Michael Loukides, who believed us when we said that this was an important
`topic and who shepherded us through the creative process; David Flanagan, for valuable feedback on
`the drafts; Hong Zhang, for helping us with Windows threading issues; and Reynold Jabbour and
`Wendy Talmont, for supporting us in our work.
`
`Mostly, we must thank our respective families. To James, who gave Scott the support and
`encouragement necessary to see this book through (and to cope with his continual state of
`distraction), and to Nini, who knew to leave Henry alone for the ten percent of the time when he was
`creative, and encouraged him the rest of the time: Thank you for everything!
`
`Finally, we must thank the many readers of the first edition of this book who sent us invaluable
`feedback. We have tried our best to answer every concern that they have raised. Keep those cards and
`letters coming!
`
` page 4
`
`TRILLER EXHIBIT 1015-009
`
`

`

`Java Threads, 2nd edition
`
`
`Chapter 1. Introduction to Threading
`This is a book about using threads in the Java programming language and the Java virtual machine.
`The topic of threads is very important in Java - so important that many features of a threaded system
`are built into the Java language itself, while other features of a threaded system are required by the
`Java virtual machine. Threading is an integral part of using Java.
`
`The concept of threads is not a new one: for some time, many operating systems have had libraries
`that provide the C programmer with a mechanism to create threads. Other languages, such as Ada,
`have support for threads embedded into the language, much as support for threads is built into the
`Java language. Nonetheless, the topic of threads is usually considered a peripheral programming
`topic, one that's only needed in special programming cases.
`
`With Java, things are different: it is impossible to write any but the simplest Java program without
`introducing the topic of threads. And the popularity of Java ensures that many developers who might
`never have considered learning about threading possibilities in a language like C or C++ need to
`become fluent in threaded programming.
`
`1.1 Java Terms
`
`We'll start by defining some terms used throughout this book. Many terms surrounding Java are used
`inconsistently in various sources; we'll endeavor to be consistent in our usage of these terms
`throughout the book.
`Java
`
`First is the term Java itself. As we know, Java started out as a programming language, and
`many people today think of Java as being simply a programming language. But Java is much
`more than just a programming language: it's also an API specification and a virtual machine
`specification. So when we say Java, we mean the entire Java platform: a programming
`language, an API, and a virtual machine specification that, taken together, define an entire
`programming and runtime environment. Often when we say Java, it's clear from context that
`we're talking specifically about the programming language, or parts of the Java API, or the
`virtual machine. The point to remember is that the threading features we discuss in this book
`derive their properties from all the components of the Java platform taken as a whole. While
`it's possible to take the Java programming language, directly compile it into assembly code,
`and run it outside of the virtual machine, such an executable may not necessarily behave the
`same as the programs we describe in this book.
`Virtual machine, interpreters, and browsers
`The Java virtual machine is another term for the Java interpreter, which is the code that
`ultimately runs Java programs by interpreting the intermediate byte-code format of the Java
`programming language. The Java interpreter actually comes in three popular forms: the
`interpreter for developers (called java) that runs programs via the command line or a file
`manager, the interpreter for end users (called jre ) that is a subset of the developer
`environment and forms the basis of (among other things) the Java plug-in, and the interpreter
`that is built into many popular web browsers such as Netscape Navigator, Internet Explorer,
`HotJava™, and the appletviewer that comes with the Java Developer's Kit. All of these forms
`are simply implementations of the Java virtual machine, and we'll refer to the Java virtual
`machine when our discussion applies to any of them. When we use the term Java interpreter,
`we're talking specifically about the command-line, standalone version of the virtual machine
`(including those virtual machines that perform just-in-time compilation); when we use the
`term Java-enabled browser (or, more simply, browser), we're talking specifically about the
`virtual machine built into web browsers.
`
`For the most part, virtual machines are indistinguishable - at least in theory. In practice, there
`are a few important differences between implementations of virtual machines, and one of
`those differences comes in the world of threads. This difference is important in relatively few
`circumstances, and we'll discuss it in Chapter 6.
`
` page 5
`
`TRILLER EXHIBIT 1015-0010
`
`

`

`Java Threads, 2nd edition
`
`
`Programs, applications, and applets
`This leads us to the terms that we'll use for things written in the Java language. Generically,
`we'll call such entities programs. But there are two types of programs a typical Java
`programmer might write: programs that can be run directly by the Java interpreter and
`programs designed to be run by a Java-enabled browser.[1] Much of the time, the distinction
`between these two types of Java programs is not important, and in those cases, we'll refer to
`them as programs. But in those cases where the distinction is important, we'll use the term
`applets for programs running in the Java-enabled browser and the term applications for
`standalone Java programs. In terms of threads, the distinction between an applet and an
`application manifests itself only in Java's security model; we'll discuss the interaction between
`the security model and Java threads in Chapter 10.
`
`[1] Though it's possible to write a single Java program so that it can be run both by the interpreter and
`by a browser, the distinction still applies at the time the program is actually run.
`
`1.2 Thread Overview
`
`This leaves us only one more term to define: what exactly is a thread? The term thread is shorthand
`for thread of control, and a thread of control is, at its simplest, a section of code executed
`independently of other threads of control within a single program.
`
`
`
`Thread of Control
`Thread of control sounds like a complicated technical term, but it's really a simple concept:
`it is the path taken by a program during execution. This determines what code will be
`executed: does the if block get executed, or does the else block? How many times does the
`while loop execute? If we were executing tasks from a "to do" list, much as a computer
`executes an application, what steps we perform and the order in which we perform them is
`our path of execution, the result of our thread of control.
`
`Having multiple threads of control is like executing tasks from two lists. We are still doing
`the tasks on each "to do" list in the correct order, but when we get bored with the tasks on
`one of the lists, we switch lists with the intention of returning at some future time to the
`first list at the exact point where we left off.
`
`
`1.2.1 Overview of Multitasking
`
`We're all familiar with the use of multitasking operating systems to run multiple programs
`simultaneously. Each of these programs has at least one thread within it, so at some level, we're
`already comfortable with the notion of a thread in a single process. The single-threaded process has
`the following properties, which, as it turns out, are shared by all threads in a program with multiple
`threads as well:
`• The process begins execution at a well-known point. In programming languages like C and
`C++ (not to mention Java itself), the thread begins execution at the first statement of the
`function or method called main() .
`• Execution of the statements follows in a completely ordered, predefined sequence for a given
`set of inputs. An individual process is single-minded in this regard: it simply executes the next
`statement in the program.
`• While executing, the process has access to certain data. In Java, there are three types of data a
`process can access: local variables are accessed from the thread's stack, instance variables are
`accessed through object references, and static variables are accessed through class or object
`references.
`
` page 6
`
`TRILLER EXHIBIT 1015-0011
`
`

`

`Java Threads, 2nd edition
`
`
`Now consider what happens when you sit at your computer and start two single-threaded programs: a
`text editor, say, and a file manager. You now have two processes running on your computer; each
`process has a single thread with the properties just outlined. Each process does not necessarily know
`about the other process, although, depending on the operating system running on your computer,
`there are several ways in which the processes can send each other various messages. A common
`behavior is that you can drag a file icon from the file manager into the text editor in order to edit the
`file. Each process thus runs independently of the other, although they can cooperate if they so choose.
`The typical multitasking environment is shown in Figure 1.1.
`
`Figure 1.1. Processes in a multitasking environment
`
`
`
`
`From the point of view of the person using the computer, these processes often appear to execute
`simultaneously, although many variables can affect that appearance. These variables depend on the
`operating system: for example, a given operating system may not support multitasking at all, so that
`no two programs appear to execute simultaneously. Or the user may have decided that a particular
`process is more important than other processes and hence should always run, shutting out the other
`processes from running and again affecting the appearance of simultaneity.
`
`Finally, the data contained within these two processes is, by default, separated: each has its own stack
`for local variables, and each has its own data area for objects and other data elements. Under many
`operating systems, the programmer can make arrangements so that the data objects reside in memory
`that can be shared between the processes, allowing both processes to access them.
`
`1.2.2 Overview of Multithreading
`
`All of this leads us to a common analogy: we can think of a thread just as we think of a process, and we
`can consider a program with multiple threads running within a single instance of the Java virtual
`machine just as we consider multiple processes within an operating system, as we show in Figure 1.2.
`
`Figure 1.2. Multitasking versus threading
`
`
`
` page 7
`
`TRILLER EXHIBIT 1015-0012
`
`

`

`Java Threads, 2nd edition
`
`
`So it is that within a Java program, multiple threads have these properties:
`• Each thread begins execution at a predefined, well-known location. For one of the threads in
`the program, that location is the main() method; for the rest of the threads, it is a particular
`location the programmer decides on when the code is written. Note that this is true of an
`applet as well, in which case the main() method was executed by the browser itself.
`• Each thread executes code from its starting location in an ordered, predefined (for a given set
`of inputs) sequence. Threads are single-minded in their purpose, always simply executing the
`next statement in the sequence.
`• Each thread executes its code independently of the other threads in the program. If the
`threads choose to cooperate with each other, there are a variety of mechanisms we will explore
`that allow that cooperation. Exploiting those methods of cooperation is the reason why
`programming with threads is such a useful technique, but that cooperation is completely
`optional, much as the user is never required to drag a file from the file manager into the text
`editor.
`• The threads appear to have a certain degree of simultaneous execution. As we'll explore in
`Chapter 6, the degree of simultaneity depends on several factors - programming decisions
`about the relative importance of various threads as well as operating system support for
`various features. The potential for simultaneous execution is the key thing you must keep in
`mind when threading your code.
`• The threads have access to various types of data. At this point, the analogy to multiple
`processes breaks down somewhat, depending on the type of data the Java program is
`attempting to access.
`
`Each thread is separate, so that local variables in the methods that the thread is executing are
`separate for different threads. These local variables are completely private; there is no way for
`one thread to access the local variables of another thread. If two threads happen to execute the
`same method, each thread gets a separate copy of the local variables of that method. This is
`completely analogous to running two copies of the text editor: each process would have
`separate copies of the local variables.
`
`Objects and their instance variables, on the other hand, can be shared between threads in a
`Java program, and sharing these objects between threads of a Java program is much easier
`than sharing data objects between processes in most operating systems. In fact, the ability to
`share data objects easily between threads is another reason why programming with threads is
`so useful. But Java threads cannot arbitrarily access each other's data objects: they need
`permission to access the objects, and one thread needs to pass the object reference to the
`other thread.
`
`Static variables are the big exception to this analogy: they are automatically shared between
`all threads in a Java program.
`
`Don't panic over this analogy: the fact that you'll be programming with threads in Java doesn't mean
`you'll necessarily be doing the system-level type of programming you'd need to perform if you were
`writing the multitasking operating system responsible for running multiple programs. The Java
`Thread API is designed to be simple and requires little specialized skill for most common tasks.
`
`1.3 Why Threads?
`
`The notion of threading is so ingrained in Java that it's almost impossible to write even the simplest
`programs in Java without creating and using threads. And many of the classes in the Java API are
`already threaded, so that often you are using multiple threads without realizing it.
`
`Historically, threading was first exploited to make certain programs easier to write: if a program can
`be split into separate tasks, it's often easier to program the algorithm as separate tasks or threads.
`Programs that fall into this category are typically specialized and deal with multiple independent
`tasks.
`
`
` page 8
`
`TRILLER EXHIBIT 1015-0013
`
`

`

`Java Threads, 2nd edition
`
`
`The relative rareness of these types of programs makes threading in this category a specialized skill.
`Often, these programs were written as separate processes using operating-system-dependent
`communication tools such as signals and shared memory spaces to communicate between processes.
`This approach increased system complexity.
`
`The popularity of threading increased when graphical interfaces became the standard for desktop
`computers because the threading system allowed the user to perceive better program performance.
`The introduction of threads into these platforms didn't make the programs any faster, but it did create
`an illusion of faster performance for the user, who now had a dedicated thread to service input or
`display output.
`
`Recently, there's been a flurry of activity regarding a new use of threaded programs: to exploit the
`growing number of computers that have multiple processors. Programs that require a lot of CPU
`processing are natural candidates for this category, since a calculation that requires one hour on a
`single-processor machine could (at least theoretically) run in half an hour on a two-processor
`machine, or 15 minutes on a four-processor machine. All that is required is that the program be
`written to use multiple threads to perform the calculation.
`
`While computers with multiple processors have been around for a long time, we're now seeing these
`machines become cheap enough to be very widely available. The advent of less expensive machines
`with multiple processors, and of operating systems that provide programmers with thread libraries to
`exploit those processors, has made threaded programming a hot topic, as developers move to extract
`every benefit from these new machines. Until Java, much of the interest in threading centered around
`using threads to take advantage of multiple processors on a single machine.
`
`However, threading in Java often has nothing at all to do with multiprocessor machines and their
`capabilities; in fact, the first Java virtual machines were unable to take advantage of multiple
`processors on a machine, and many implementations of the virtual machine still follow that model.
`However, there are also implementations of the virtual machine that do take advantage of the multiple
`processors that the computer may have. A correctly written program running in one of those virtual
`machines on a computer with two processors may indeed take roughly half the time to execute that it
`would take on a computer with a single processor. If you're looking to use Java to have your program
`scale to many processors, that is indeed possible when you use the correct virtual machine. However,
`even if your Java program is destined to be run on a machine with a single CPU, threading is still very
`important.
`
`The major reason threading is so important in Java is that Java has no concept of asynchronous
`behavior. This means that many of the programming techniques you've become accustomed to using
`in typical programs are not applicable in Java; instead, you must learn a new repertoire of threading
`techniques to handle these cases of asynchronous behavior.
`
`This is not to say t