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

About the Reviewers

Edward E. Griebel Jr’s first introduction to computers was in elementary school through LOGO on an Apple and The Oregon Trail on a VAX. Pursuing his interest in computers, he graduated from Bucknell University with a degree in Computer Engineering. At his first job, he quickly realized he didn’t know everything that there was to know about computer programming. He has spent the past 20 years honing his skills in the securities trading, telecommunications, payroll processing, and machine-to-machine communications industries as a developer, team leader, consultant, and mentor. Currently working on enterprise development in Java EE, he feels that any day spent writing a code is a good day.

Jacek Laskowski is a professional software specialist using a variety of commercial and open source solutions to meet customer’s demands. He develops applications, writes articles, guides less-experienced engineers, records screen casts, delivers courses, and has been a technical reviewer for many IT books.

He focuses on Java EE, Service-Oriented Architecture (SOA), Business Process Management (BPM) solutions, OSGi, and functional languages (Clojure and F#). He’s into Scala, Dart, native Android development in Java and HTML 5.

He is the founder and leader of the Warszawa Java User Group (Warszawa JUG). He is also a member of the Apache Software Foundation, and a PMC and committer of Apache OpenEJB and Apache Geronimo projects.

He regularly speaks at developer conferences. He blogs at http://blog.japila.pl and http://blog.jaceklaskowski.pl. Follow him on twitter @jaceklaskowski.

He has been working for IBM for over 6 years now and is currently a Certified IT Specialist (Level 2) in the World-wide Web Sphere Competitive Migration Team. He assists customers in their migrations from competitive offerings, mostly Oracle WebLogic Server, to the IBM WebSphere Application Server.

He’s recently been appointed to the IBM Academy of Technology.

Abraham Tehrani, over a decade, has software development experience as a developer and QA engineer. Also, he is passionate about quality and technology.

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

About the Reviewers