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

Exercises

The following exercises will improve your skills in building practical concurrent applications. Some of them require extending the ScalaFTP program from this chapter, while others require implementing concurrent applications from scratch. Finally, several exercises are dedicated to testing the performance and scalability of concurrent programs.

Extend the ScalaFTP application to allow adding directories to the remote filesystem.
Extend the ScalaFTP application so that the changes in the server filesystem are automatically reflected in the client program.
Extend the ScalaFTP application so that it allows parallel regex searches over filenames in the remote filesystem.
Extend the ScalaFTP server so that it allows recursively copying directories.
Implement the download and upload functionality, and use Observable objects to display the file transfer progress in a Swing ProgressBar component.
Extend the ScalaFTP client implementation so that a FilePane can display either a remote or a local...

Search

Your notes and bookmarks