Java 7 Concurrency Cookbook

Java 7 Concurrency Cookbook

By : Javier Fernández González

Buy this Book

Java 7 Concurrency Cookbook

By: Javier Fernández González

Buy this Book

Overview of this book

<p><undefined:p><undefined:undefined:p>Java remains the global standard for developing various applications and enterprise software, and the launch of Java 7 brings with it exciting new capabilities for concurrent programming by way of the concurrency utilities enhancement. This allows developers to make the most of their applications with parallel task performance. "Java 7 Concurrency Cookbook" covers all elements of the Java concurrency API, providing essential recipes for taking advantage of the exciting new capabilities.<undefined:undefined:br><undefined:undefined:br>On your computer, you can listen to music while you edit a Word document and read your emails, all at once! This is because your operating system allows the concurrency of tasks, much like the Java platform which offers various classes to execute concurrent tasks inside a Java program. "Java 7 Concurrency Cookbook" covers the most important features of the Java concurrency API, with special emphasis on the new capabilities of version 7. <undefined:undefined:br><undefined:undefined:br>With each version, Java increases the available functionality to facilitate development of concurrent programs. This book covers the most important and useful mechanisms included in version 7 of the Java concurrency API, so you will be able to use them directly in your applications.<undefined:undefined:br><undefined:undefined:br>"Java 7 Concurrency Cookbook" includes recipes to enable you to achieve everything from the basic management of threads and tasks, to the new Fork /Join framework, through synchronization mechanisms between tasks, different types of concurrent tasks that Java can execute, data structures that must be used in concurrent applications and the classes of the library that can be customized.<undefined:undefined:br><undefined:undefined:br>With the step-by-step examples in this book you’ll be able to apply the most important and useful features of the Java 7 concurrency API.</undefined:undefined:br></undefined:undefined:br></undefined:undefined:br></undefined:undefined:br></undefined:undefined:br></undefined:undefined:br></undefined:undefined:br></undefined:undefined:br></undefined:undefined:p></undefined:p></p>

Java 7 Concurrency Cookbook

Credits

About the Author

About the Reviewers

www.PacktPub.com

Preface

Free Chapter

Thread Management

Introduction

Creating and running a thread

Getting and setting thread information

Interrupting a thread

Controlling the interruption of a thread

Sleeping and resuming a thread

Waiting for the finalization of a thread

Creating and running a daemon thread

Processing uncontrolled exceptions in a thread

Using local thread variables

Grouping threads into a group

Processing uncontrolled exceptions in a group of threads

Creating threads through a factory

Basic Thread Synchronization

Introduction

Synchronizing a method

Arranging independent attributes in synchronized classes

Using conditions in synchronized code

Synchronizing a block of code with a Lock

Synchronizing data access with read/write locks

Modifying Lock fairness

Using multiple conditions in a Lock

Thread Synchronization Utilities

Introduction

Controlling concurrent access to a resource

Controlling concurrent access to multiple copies of a resource

Waiting for multiple concurrent events

Synchronizing tasks in a common point

Running concurrent phased tasks

Controlling phase change in concurrent phased tasks

Changing data between concurrent tasks

Thread Executors

Introduction

Creating a thread executor

Creating a fixed-size thread executor

Executing tasks in an executor that returns a result

Running multiple tasks and processing the first result

Running multiple tasks and processing all the results

Running a task in an executor after a delay

Running a task in an executor periodically

Canceling a task in an executor

Controlling a task finishing in an executor

Separating the launching of tasks and the processing of their results in an executor

Controlling rejected tasks of an executor

Fork/Join Framework

Introduction

Creating a Fork/Join pool

Joining the results of the tasks

Running tasks asynchronously

Throwing exceptions in the tasks

Canceling a task

Concurrent Collections

Introduction

Using non-blocking thread-safe lists

Using blocking thread-safe lists

Using blocking thread-safe lists ordered by priority

Using thread-safe lists with delayed elements

Using thread-safe navigable maps

Generating concurrent random numbers

Using atomic variables

Using atomic arrays

Customizing Concurrency Classes

Introduction

Customizing the ThreadPoolExecutor class

Implementing a priority-based Executor class

Implementing the ThreadFactory interface to generate custom threads

Using our ThreadFactory in an Executor object

Customizing tasks running in a scheduled thread pool

Implementing the ThreadFactory interface to generate custom threads for the Fork/Join framework

Customizing tasks running in the Fork/Join framework

Implementing a custom Lock class

Implementing a transfer Queue based on priorities

Implementing your own atomic object

Testing Concurrent Applications

Introduction

Monitoring a Lock interface

Monitoring a Phaser class

Monitoring an Executor framework

Monitoring a Fork/Join pool

Writing effective log messages

Analyzing concurrent code with FindBugs

Configuring Eclipse for debugging concurrency code

Configuring NetBeans for debugging concurrency code

Testing concurrency code with MultithreadedTC

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Implementing a priority-based Executor class

In the first versions of the Java concurrency API, you had to create and run all the threads of your application. In Java Version 5, with the appearance of the Executor framework, a new mechanism was introduced for the execution of concurrency tasks.

With the Executor framework, you only have to implement your tasks and send them to the executor. The executor is responsible for the creation and execution of the threads that execute your tasks.

Internally, an executor uses a blocking queue to store pending tasks. These are stored in the order of their arrival to the executor. One possible alternative is the use of a priority queue to store new tasks. In this way, if a new task with high priority arrives to the executor, it will be executed before other threads that have already been waiting for a thread to execute, but have lower priority.

In this recipe, you will learn how to implement an executor that will use a priority queue to store the tasks...

Java 7 Concurrency Cookbook

By : Javier Fernández González

Java 7 Concurrency Cookbook

By: Javier Fernández González

Overview of this book

Related Content you might be interested in

Current Title:

Java 7 Concurrency Cookbook

Implementing a priority-based Executor class