Book Image

Java 7 Concurrency Cookbook

By : Javier Fernández González
Book Image

Java 7 Concurrency Cookbook

By: Javier Fernández González

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&rsquo;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>

Related Content you might be interested in

Current Title:

Small book image
Java 7 Concurrency Cookbook
Javier Fernández González
Oct, 2012 | 364 pages
No titles found
Table of Contents (15 chapters)
Java 7 Concurrency Cookbook
Java 7 Concurrency Cookbook
Credits
Credits
About the Author
About the Author
About the Reviewers
About the Reviewers
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Free Chapter
1
Thread Management
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
2
Basic Thread Synchronization
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
3
Thread Synchronization Utilities
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
4
Thread Executors
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
5
Fork/Join Framework
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
6
Concurrent Collections
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
7
Customizing Concurrency Classes
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
8
Testing Concurrent Applications
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
Index

Writing effective log messages

A log system is a mechanism that allows you to write information to one or more destinations. A Logger has the following components:

  • One or more handlers: A handler will determine the destination and the format of log messages. You can write log messages to the console, a file, or a database.

  • A name: Usually, the name of a Logger used in a class that's based on the class name and its package name.

  • A level: Log messages have a level associated that indicates its importance. A Logger also has a level used to decide what messages it is going to write. It only writes the messages that are as important as, or more important, than its level.

You should use the log system with the following two main purposes:

  • Write as much information as you can when an exception is caught. This will help to localize the error and resolve it.

  • Write information about the classes and methods that the program is executing.

In this recipe, you will learn how to use the classes provided by...

Previous Section
End of Section 7
Next Section