High-Performance Java Platform Computing : Multithreaded and Networked Programming

Overview

  • The clear, practical guide to Java threads and concurrency
  • Proven design patterns and extensive code library
  • Expert techniques for optimizing networked/distributed applications
  • Avoiding deadlocks, race conditions, and synchronization problems

Threading, concurrency, and beyond: Your crystal-clear Java performance guide and code library!

...

See more details below
Available through our Marketplace sellers.
Other sellers (Paperback)
  • All (12) from $1.99   
  • New (2) from $93.49   
  • Used (10) from $1.99   
Close
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any BN.com coupons and promotions
$93.49
Seller since 2014

Feedback rating:

(298)

Condition:

New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

New
Brand New Item.

Ships from: Chatham, NJ

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$105.00
Seller since 2014

Feedback rating:

(187)

Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Page 1 of 1
Showing All
Close
Sort by
Sending request ...

Overview

  • The clear, practical guide to Java threads and concurrency
  • Proven design patterns and extensive code library
  • Expert techniques for optimizing networked/distributed applications
  • Avoiding deadlocks, race conditions, and synchronization problems

Threading, concurrency, and beyond: Your crystal-clear Java performance guide and code library!

Threading and concurrency are crucial to building high-performance Java applications — but they have a reputation for complexity. High-Performance Java Computing thoroughly demystifies them, helping developers leverage threading and concurrency to solve a wide variety of performance problems — especially in networked, distributed applications. This book delivers practical solutions, proven design patterns, and a rigorously tested code library: everything you need to build optimized Java software for technical, business, and e-Commerce applications. Coverage includes:

  • Java 2 Threads classes: daemon threads, thread control, scheduling, and more
  • Solving the key problems of parallelism: deadlocks, race conditions, and synchronization
  • Advanced techniques for optimizing concurrent code
  • Java monitors, parallelizing loops, and parallel execution of subroutines in shared memory
  • New design patterns for distributed application development

There's never been a more accessible, practical guide to Java multi-threading, concurrency, and other high-performance techniques. When performance really matters, turn to High-Performance Java Computing — and find the solution you're searching for!

Read More Show Less

Editorial Reviews

From Barnes & Noble
The Barnes & Noble Review
Today's symmetric multiprocessing systems and networked workstation clusters make available incredible amounts of processing power. But few developers are comfortable with the techniques needed to leverage all that power -- techniques such as multi-threading and concurrency. In this book, two leading high-performance developers demystify these techniques, showing exactly how to maximize the performance of high-end server-side systems running Java.

The authors walk you through essential threading and concurrency concepts from scratch, with exceptional clarity. Next, they focus on the key obstacles developers encounter in building high-performance code, including deadlocks, race conditions, and synchronization problems.

You'll learn how to make the most of Java's built-in features for high-performance computing, such as its built-in support for concurrency via a monitor-like abstraction. However, the authors recognize the limits of Java's built-in capabilities. For example, while monitors can solve many classical synchronization problems, they break down as more complex libraries and software systems are developed. You need new strategies -- and you'll find them here.

High-Performance Java Platform Computing covers topics rarely addressed in other books on either Java or multithreading: extending the threads model to a network of JVMs; high-level approaches to shared- and distributed-memory multithreading; and more. You'll also find benchmarks comparing the performance of parallel algorithms.

Best of all, you'll find an extensive library of downloadable sample code -- some of it designed for instruction, the rest designed specifically for reuse. (Bill Camarda)

Bill Camarda is a consultant and writer with nearly 20 years' experience in helping technology companies deploy and market advanced software, computing, and networking products and services. His 15 books include Special Edition Using Word 2000 and Upgrading & Fixing Networks For Dummies®, Second Edition.

Read More Show Less

Product Details

  • ISBN-13: 9780130161642
  • Publisher: Pearson Education
  • Publication date: 8/31/2000
  • Series: Sun Microsystems Press Series
  • Edition number: 1
  • Pages: 350
  • Product dimensions: 6.95 (w) x 9.15 (h) x 1.11 (d)

Meet the Author


Thomas W. Christopher and George K. Thiruvathukal are principals in Tools of Computing LLC, a Chicago-area consulting firm specializing in high-performance computing and object-oriented languages. A professor of Computer Science for over twenty years, Christopher has written several compilers. Thiruvathukal, a former computer scientist at Argonne National Laboratories, is now a visiting professor at Loyola University in Chicago and Secretary General of the Java Grande Group, whose aim is to advance Java-based scientific and technical computing.
Read More Show Less

Read an Excerpt

PREFACE:

Preface

This is a book about programming high-performance multithreaded applications using the Java language.

Multithreading and multiprogramming, long heralded as useful ideas in the computing literature, have been the focus of numerous textbooks on operating systems, parallel and distributed computing, and, most, recently Java. Yet a key question remains unanswered: Why would one really use threads in the first place?

Our book attacks this question from the bottom up and the top down. Beginning with the bottom-up discussion, threads have been created with the primary goal of improving performance of software applications. At a low level, a thread is much like a process, but differs from processes in one key respect: resource consumption. This is because threads, unlike processes, share common code and data, thus having a lower cost of creation and context-switching overhead.

On the other hand, the low-level focus on threads-the mechanism-has much to do with why threads have not achieved widespread usage in applications. Threads do allow great advances in performance to be made, but not without some up-front program structuring. The fact that all threads share data structures can in many cases lead to poor performance, due to synchronization costs.

To answer the question posed earlier, we believe multithreading exists primarily to allow performance gains to be realized, particularly on scalable hardware platforms, such as parallel supercomputers, workstation clusters, and symmetric multiprocessor (SMP) systems. Our book emphasizes programming techniques and packages for high-end computing (often called the "server side" inthe business world). We are concerned with using the power available on multiprocessor computers and computer networks to perform computations rapidly.

This book was conceived as a natural follow-up to a successful series of short courses we offered at the Illinois Institute of Technology and elsewhere to working professionals and graduate students alike. Additionally, between us we have approximately two decades of relevant teaching and research experience in the fields of high-performance computing, object-oriented systems, programming languages, and operating systems.

Our research in high-performance computing and languages has always focused on facilitating the development of concurrent, parallel, and distributed software, going back as far as 1988, when we first began working together on the Message Driven Computing (MDC) environment. We have developed a number of working programming languages and libraries to support such software development. All of the work we did in the past, however, was done in the C, Icon, and C++ programming languages. For this book, we have reworked many of our ideas into a form more suitable for the practicing software engineer, while fully exploiting the power of a true object language such as Java.

With its built-in support for concurrency via a monitorlike abstraction, Java makes concurrent programming easier for programmers than languages such as C and C++. We will discuss how monitors are adequate for solving many problems in concurrency, particularly the so-called classical synchronization problems, which have been well documented in operating-systems textbooks. As more complex libraries and software systems are developed, the evidence gathered supports the proposition that monitors, much like other low-level mechanisms for synchronization, break down. Monitors, despite being a higher-level mechanism for supporting concurrency, present the same problems as found in "less sophisticated" environments such as C and C++ (where low-level threads libraries, such as pthreads and Win32 threads, are used). We refer in the text to these problems (race conditions and deadlocks) as enemies. We present stategies for dealing with these enemies and a number of higher-level frameworks that enable the programmer to worry less often about them.

Java is one of the great programming languages of our time. Like many of the great programming languages, a company was behind its development, adoption, and popularity. The sensational marketing blitz was enough to make many of us think that all of the work on languages was now complete, so we could start packing our bags and look for other work. Now that the dust has settled, it is clear that Java does occupy an important space in the marketplace; however, there is a great deal of potential for exploring other programming languages and techniques. The environments in which Java is being considered will require at least a subset of the ideas presented in this book: network appliances, server-side computing, workstation clustering, and parallel systems, to name a few. In this book, our aim is to give the reader some insight into what Java does and does not provide, in terms of support for concurrency. What Java does not provide, we do provide with a working library of Java code that allows the programmer to "operate at a higher-level" (to borrow a phrase from IBM marketing from the OS/2 days).

This book, like all books, does not exist in a vacuum. There are a number of competing books, some of which are appearing in new editions during the next year. We believe our book will be the first of its kind in terms of multithreading and its application to real-world programming. It also provides the following benefits and features:

  1. It presents a human-understandable explanation of multithreading, its implementation, and how it works in Java.
  2. It helps the programmer to understand the very real problems encountered in concurrent systems, focused on race conditions, deadlock, and problems encountered when introducing parallelism and distribution. This particular aspect of our book brings to life the chapters on concurrency presented in "abstract" OS textbooks, wherein working code examples are seldom, if ever, provided.
  3. It helps the programmer to understand the classic synchronization problems, which have suddenly been placed in the spotlight as more and more code is (incorrectly) being written to exploit concurrency.
  4. It introduces high-level approaches to shared- and distributed-memory multithreading. This section will be of great interest to those who want to develop multithreaded applications but prefer to work at a higher level.
  5. It shows how to extend the threads concept to the network. It shows how to extend the threads model beyond the single Java Virtual Machine (JVM) to a network of JVMs.

We hope you enjoy this book. It has been written to address the needs of a broad audience. There is introductory, intermediate, and advanced material. The book is designed to be progressive and can be used either as a reference or as a companion to a variety of courses. Exercises are provided at the end of each chapter to reinforce the principles.

Speaking of Code

Code for the Tools of Computing thread package is available through our company Web site at ...

Read More Show Less

Table of Contents

1: Foundations
The von Neumann Machine
Flynn's Taxonomy
Control-Memory Taxonomy
Speedup and Efficiency
Amdahl's Law
Scalability
Problems of Parallelism
Grain Size
Starvation
Deadlock
Flooding and Throttling
Layout
Latency
Scheduling
Programming Techniques
Chapter Wrap-up
Exercises
2: Threads
Why Is Multithreading Useful?
Overview of the Java Threads Classes
Thread: The Class Responsible for Thread Creation and Execution
Runnable: Making Threads Without Extending the Thread Class
Hello World: A First Example of Multithreading
Implementing Interfaces and Extending Classes: What's the Deal?
Concepts
A Little Bit of History
Some Definitions
Multiprogramming vs Multitasking
Concurrency vs Parallelism vs Distribution
Threads vs Processes
Kernel-level vs User-level Threads
Quick Tour of Java Threads Functions
Construction
Daemon Threads
Thread Control
Very Useful Static Methods
Thread Synchronization
Cooperative Multitasking
Prioritized Scheduling
Miscellaneous Status Methods
Methods Not Covered Here
Exercises
3: Race Conditions and Mutual Exclusion
Know Your Enemy
Race Conditions
Egoist: A First Study in Race Conditions
A Word on Priorities
What Is a Race Condition?
Race0 Class
Critical Sections and Object Locking
Race1 Class-Fixing Race0 with Synchronization
Conditions
Motivating the Need for Conditions
Key Object Methods Needed to Work with Conditions in Java
File Copying: A Producer-Consumer Example
Locks-Binary Semaphores: An Example of Using Conditions
Race2: Reworked Race1 Using Locks
Classic Synchronization Mechanisms
Counting Semaphore
Barrier
Futures
Deadlock
What Is Deadlock?
How to Know When Deadlock Has Hit You?
Four Conditions of Deadlock
A Classic Example: Dining Philosophers
Chapter Wrap-up
Exercises
4: Monitors
Real Monitors and Java Monitors
Class Monitor in the Thread Package
Monitor's Methods
Interface MonitorCondition's Methods
Interface MonitorLock
Examples using Monitor Objects
SimpleFuture
SharedTableOfQueues
Implementation of Monitor, Condition, and MonitorLock
Monitor Entry and Exit
Monitor
Condition
Monitor
Lock
The Multiple Reader-Writer Monitors
Policies
Entering and Leaving the Critical Sections
The Single-Reader-Writer Monitor
The Readers-Preferred Monitor
The Writers-Preferred Monitor
The Alternating Readers-Writers Monitor
The Take-a-Number Monitor
Chapter Wrap-up
Exercises
5: Parallel Execution of Subroutines in Shared Memory
Creating and Joining
Example: Trapezoidal Numeric Integration
RunQueue
RunQueue Methods
RunQueue Implementation
Recursive Shell Sort: RunQueues and SimpleFutures
Accumulator
Accumulator Operations
Patterns of Use of Accumulators
Using Accumulators
Numeric Integration
TerminationGroup
Combinatorial Search
The 0-1 Knapsack Problem
Parallel Depth-first Search for the Knapsack Problem
Knapsack2
PriorityRunQueue
Branch-and-Bound with Priority Run Queues
Branch and Bound for 0-1 Knapsack
A Purer Branch-and-Bound 0-1 Knapsack
Chapter Wrap-up
Exercises
6: Parallelizing Loops
Chore Graphs
Gathering Chores into Threads
Example: Warshall's Algorithm
Static Scheduling
Dynamic Scheduling
Example: Longest Common Subsequence
Example: Shell Sort
Chapter Wrap-up
Exercises
7: Chores
The RunDelayed Interface
Futures
FutureFactory
Chore-programming Techniques
Job Jars
Chore Graphs
Macro Dataflow
Flow of Control
Macro Dataflow Examples: Vector Addition
Continuations to Separate Operand Fetch from Operation
Static Dataflow Style and Storing Operands in Instructions
Fetching in Continuations
Chore examples: Warshall's Algorithm
WarshallDF1 and Warshall's Algorithm in Dataflow
WarshallC1 through WarshallC3: Chores, But Not Dataflow
Chapter Wrap-up
Exercises
8: Thread and Chore Synchronization
TerminationGroup
Barrier
BarrierFactory
AccumulatorFactory
Parallel Quicksort
Shell Sort
Chapter Wrap-up
9: Shared Tables of Queues
Shared Tables of Queues
Methods
Implementing Synchronizations Using a Shared Table of Queues
Indexed Keys
Implementing More Synchronizations and Shared Structures
Reactive Objects
Communicating through a Shared Table of Queues
Future Queues
Methods
Implementation of FutureQueue
Example of FutureQueue: The Queued Readers-Writers Monitor
Future Tables
Chapter Wrap-up
Exercises
10: Streams Essentials
The Streams Abstraction
Building Your Own Stream
Caesar Cipher: Very Basic Encryption
Chapter Wrap-up
Exercises
11: Networking
Exploring the Client Side
Services: The Internet Story
Destination Sendmail
Java Networking: Socket and InetAddress
Where Are the Services?
A Kind and Gentle Introduction to the Server Side
Iterative Servers
Simple Messaging Architecture
The Message Class
DateService and DateClient SMA Style
Chapter Wrap-Up
Exercises
12: Coordination
Generic Mailbox Invocations
GMI: Goals and Design Overview
Callable: An Interface for Accepting Communication
CallMessage: An Abstract Class for Marshalling and Unmarshalling!
RemoteCallServer
RemoteCallServerDispatcher
MemoServer
MemoClient
Vector Inner Product
Trapezoidal Integration
Warshall's Algorithm
Chapter Wrap-up
Exercises
Index
Read More Show Less

Preface

PREFACE:

Preface

This is a book about programming high-performance multithreaded applications using the Java language.

Multithreading and multiprogramming, long heralded as useful ideas in the computing literature, have been the focus of numerous textbooks on operating systems, parallel and distributed computing, and, most, recently Java. Yet a key question remains unanswered: Why would one really use threads in the first place?

Our book attacks this question from the bottom up and the top down. Beginning with the bottom-up discussion, threads have been created with the primary goal of improving performance of software applications. At a low level, a thread is much like a process, but differs from processes in one key respect: resource consumption. This is because threads, unlike processes, share common code and data, thus having a lower cost of creation and context-switching overhead.

On the other hand, the low-level focus on threads-the mechanism-has much to do with why threads have not achieved widespread usage in applications. Threads do allow great advances in performance to be made, but not without some up-front program structuring. The fact that all threads share data structures can in many cases lead to poor performance, due to synchronization costs.

To answer the question posed earlier, we believe multithreading exists primarily to allow performance gains to be realized, particularly on scalable hardware platforms, such as parallel supercomputers, workstation clusters, and symmetric multiprocessor (SMP) systems. Our book emphasizes programming techniques and packages for high-end computing (often called the "server side"inthe business world). We are concerned with using the power available on multiprocessor computers and computer networks to perform computations rapidly.

This book was conceived as a natural follow-up to a successful series of short courses we offered at the Illinois Institute of Technology and elsewhere to working professionals and graduate students alike. Additionally, between us we have approximately two decades of relevant teaching and research experience in the fields of high-performance computing, object-oriented systems, programming languages, and operating systems.

Our research in high-performance computing and languages has always focused on facilitating the development of concurrent, parallel, and distributed software, going back as far as 1988, when we first began working together on the Message Driven Computing (MDC) environment. We have developed a number of working programming languages and libraries to support such software development. All of the work we did in the past, however, was done in the C, Icon, and C++ programming languages. For this book, we have reworked many of our ideas into a form more suitable for the practicing software engineer, while fully exploiting the power of a true object language such as Java.

With its built-in support for concurrency via a monitorlike abstraction, Java makes concurrent programming easier for programmers than languages such as C and C++. We will discuss how monitors are adequate for solving many problems in concurrency, particularly the so-called classical synchronization problems, which have been well documented in operating-systems textbooks. As more complex libraries and software systems are developed, the evidence gathered supports the proposition that monitors, much like other low-level mechanisms for synchronization, break down. Monitors, despite being a higher-level mechanism for supporting concurrency, present the same problems as found in "less sophisticated" environments such as C and C++ (where low-level threads libraries, such as pthreads and Win32 threads, are used). We refer in the text to these problems (race conditions and deadlocks) as enemies. We present stategies for dealing with these enemies and a number of higher-level frameworks that enable the programmer to worry less often about them.

Java is one of the great programming languages of our time. Like many of the great programming languages, a company was behind its development, adoption, and popularity. The sensational marketing blitz was enough to make many of us think that all of the work on languages was now complete, so we could start packing our bags and look for other work. Now that the dust has settled, it is clear that Java does occupy an important space in the marketplace; however, there is a great deal of potential for exploring other programming languages and techniques. The environments in which Java is being considered will require at least a subset of the ideas presented in this book: network appliances, server-side computing, workstation clustering, and parallel systems, to name a few. In this book, our aim is to give the reader some insight into what Java does and does not provide, in terms of support for concurrency. What Java does not provide, we do provide with a working library of Java code that allows the programmer to "operate at a higher-level" (to borrow a phrase from IBM marketing from the OS/2 days).

This book, like all books, does not exist in a vacuum. There are a number of competing books, some of which are appearing in new editions during the next year. We believe our book will be the first of its kind in terms of multithreading and its application to real-world programming. It also provides the following benefits and features:

  1. It presents a human-understandable explanation of multithreading, its implementation, and how it works in Java.
  2. It helps the programmer to understand the very real problems encountered in concurrent systems, focused on race conditions, deadlock, and problems encountered when introducing parallelism and distribution. This particular aspect of our book brings to life the chapters on concurrency presented in "abstract" OS textbooks, wherein working code examples are seldom, if ever, provided.
  3. It helps the programmer to understand the classic synchronization problems, which have suddenly been placed in the spotlight as more and more code is (incorrectly) being written to exploit concurrency.
  4. It introduces high-level approaches to shared- and distributed-memory multithreading. This section will be of great interest to those who want to develop multithreaded applications but prefer to work at a higher level.
  5. It shows how to extend the threads concept to the network. It shows how to extend the threads model beyond the single Java Virtual Machine (JVM) to a network of JVMs.

We hope you enjoy this book. It has been written to address the needs of a broad audience. There is introductory, intermediate, and advanced material. The book is designed to be progressive and can be used either as a reference or as a companion to a variety of courses. Exercises are provided at the end of each chapter to reinforce the principles.

Speaking of Code

Code for the Tools of Computing thread package is available through our company Web site at ...

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously

    If you find inappropriate content, please report it to Barnes & Noble
    Why is this product inappropriate?
    Comments (optional)