Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Learning Concurrent Programming in Scala

By : Prokopec

4.7 (10)

Learning Concurrent Programming in Scala

4.7 (10)

By: Prokopec

Overview of this book

This book is a must-have tutorial for software developers aiming to write concurrent programs in Scala, or broaden their existing knowledge of concurrency. This book is intended for Scala programmers that have no prior knowledge about concurrent programming, as well as those seeking to broaden their existing knowledge about concurrency. Basic knowledge of the Scala programming language will be helpful. Readers with a solid knowledge in another programming language, such as Java, should find this book easily accessible.

Preface

Preface

How this book is organized

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

1. Introduction

1. Introduction

Concurrent programming

The advantages of Scala

Preliminaries

Summary

Exercises

2. Concurrency on the JVM and the Java Memory Model

2. Concurrency on the JVM and the Java Memory Model

Processes and Threads

Monitors and synchronization

Volatile variables

The Java Memory Model

Summary

Exercises

3. Traditional Building Blocks of Concurrency

3. Traditional Building Blocks of Concurrency

The Executor and ExecutionContext objects

Atomic primitives

Lazy values

Concurrent collections

Creating and handling processes

Summary

Exercises

4. Asynchronous Programming with Futures and Promises

4. Asynchronous Programming with Futures and Promises

Futures

Promises

Futures and blocking

The Scala Async library

Alternative Future frameworks

Summary

Exercises

5. Data-Parallel Collections

5. Data-Parallel Collections

Scala collections in a nutshell

Using parallel collections

Caveats of parallel collections

Using parallel and concurrent collections together

Implementing custom parallel collections

Alternative data-parallel frameworks

Summary

Exercises

6. Concurrent Programming with Reactive Extensions

6. Concurrent Programming with Reactive Extensions

Creating Observable objects

Composing Observable objects

Rx schedulers

Subjects and top-down reactive programming

Summary

Exercises

7. Software Transactional Memory

7. Software Transactional Memory

The trouble with atomic variables

Using Software Transactional Memory

Composing transactions

Retrying transactions

Transactional collections

Summary

Exercises

8. Actors

8. Actors

Working with actors

Communication between actors

Actor supervision

Remote actors

Summary

Exercises

9. Concurrency in Practice

9. Concurrency in Practice

Choosing the right tools for the job

Putting it all together – a remote file browser

Debugging concurrent programs

Summary

Exercises

Index

Index

Customer Reviews

4.7 (10)

5 star

70%

4 star

30%

3 star

0

2 star

0

1 star

0

Caveats of parallel collections

Parallel collections were designed to provide a programming API similar to sequential Scala collections. Every sequential collection has a parallel counterpart and most operations have the same signature in both sequential and parallel collections. Still, there are some caveats when using parallel collections, and we will study them in this section.

Non-parallelizable collections

Parallel collections use splitters, represented with the Splitter[T] type, in order to provide parallel operations. A splitter is a more advanced form of an iterator; in addition to the iterator's next and hasNext methods, splitters define the split method that divides the splitter S into a sequence of splitters that traverse parts of S:

def split: Seq[Splitter[T]]

This method allows separate processors to traverse separate parts of the input collection. The split method must be implemented efficiently, as this method is invoked many times during the execution of a parallel operation...

Search

Your notes and bookmarks