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

Choosing the right tools for the job

In this section, we present an overview of the different concurrency libraries that we learned about. We take a step back and look at the differences between these libraries, and what they have in common. This summary will give us an insight into what different concurrency abstractions are useful for.

A concurrency framework usually needs to address several concerns:

It must provide a way to declare data that is shared between concurrent executions
It must provide constructs for reading and modifying program data
It must be able to express conditional execution, triggered when a certain set of conditions are fulfilled
It must define a way to start concurrent executions

Some of the frameworks from this book address all of these concerns; others address only a subset, and transfer part of the responsibility to another framework.

Typically, in a concurrent programming model, we express concurrently shared data differently from data intended to be accessed only...

Search

Your notes and bookmarks