Preface
Chapter 1： Why JavaScript Concurrency?
Synchronous JavaScript
Synchronicity is easy to understand
Asynchronous is inevitable
Asynchronous browsers
Types of concurrency
Asynchronous actions
Parallel actions
JavaScript concurrency principles： Parallelize， Synchronize，
Conserve
Parallelize
Synchronize
The Promise API
Conserve
Summary
Chapter 2： The JavaScript Execution Model
Everything is a task
Meet the players
The Execution environment
Event loops
Task queues
Execution contexts
Maintaining execution state
Job queues
Creating tasks using timers
Using setTimeout（）
Using setlnterval（）
Responding to DOM events
Event targets
Managing event frequency
Responding to network events
Making requests
Coordinating requests
Concurrency challenges with this model
Limited opportunity for parallelism
Synchronization through callbacks
Summary
Chapter 3： Synchronizing with Promises
Promise terminology
Promise
State
Executor
Resolver
Rejector
Thenable
Resolving and rejecting promises
Resolving promises
Rejecting promises
Empty promises
Reacting to promises
Resolution job queues
Using promised data
Error callbacks
Always reacting
Resolving other promises
Promise-like objects
Building callback chains
Promises only change state once
Immutable promises
Many then callbacks， many promises
Passing promises around
Synchronizing several promises
Waiting on promises
Cancelling promises
Promises without executors
Summary
Chapter 4： Lazy Evaluation with Generators
Call stacks and memory allocation
Bookmarking function contexts
Sequences instead of arrays
Creating generators and yielding values
Generator function syntax
Yielding values
Iterating over generators
Infinite sequences
No end in sight
Alternating sequences
Deferring to other generators
Selecting a strategy
Interweaving generators
Passing data to generators
Reusing generators
Lightweight map/reduce
Coroutines
Creating coroutine functions
Handling DOM events
Handling promised values
Summary
Chapter 5： Working with Workers
What are workers?
OS threads
Event targets
True parallelism
Types of workers
Dedicated workers
Sub-workers
Shared workers
Worker environments
What's available， what isn't?
Loading scripts
Communicating with workers
Posting messages
Message serialization
Receiving messages from workers
Sharing application state
Sharing memory
Fetching resources
Communicating between pages
Performing sub-tasks with sub-workers
Dividing work into tasks
A word of caution
Error handling in web workers
Error condition checking
Exception handling
Summary
Chapter 6： Practical Parallelism
Functional programming
Data in， data out
Immutability
Referential transparency and time
Do we need to go parallel?
How big is the data?
Hardware concurrency capabilities
Creating tasks and assigning work
Candidate problems
Embarrassingly parallel
Searching collections
Mapping and reducing
Keeping the DOM responsive
Bottom halves
Translating DOM manipulation
Translating DOM events
Summary
Chapter 7： Abstracting Concurrency
Writing concurrent code
Hiding the concurrency mechanism
Without concurrency
Worker communication with promises
Helper functions
Extending postMessage0
Synchronizing worker results
Lazy workers
Reducing overhead
Generating values in workers
Lazy worker chains
Using Parallel．js
How it works
Spawning workers
Mapping and reducing
Worker pools
Allocating pools
Scheduling jobs
Summary
Chapter 8： Evented IO with NodeJS
Single threaded IO
IO is slow
IO events
Multi-threading challenges
More connections， more problems
Deploying to the Internet
The C10K problem
Lightweight event handlers
Evented network IO
Handling HTTP requests
Streaming responses
Proxy network requests
Evented file IO
Reading from files
Writing to files
Streaming reads and writes
Summary
Chapter 9： Advanced NodeJS Concurrency
Coroutines with Co
Generating promises
Awaiting values
Resolving values
Asynchronous dependencies
Wrapping coroutines
Child Processes
Blocking the event loop
Forking processes
Spawning external processes
Inter-process communication
Process Clusters
Challenges with process management
Abstracting process pools
Server clusters
Proxying requests
Facilitating micro-services
Informed load balancing
Summary
Chapter 10： Building a Concurrent Application
Getting started
Concurrency first
Retrofitting concurrency
Application types
Requirements
The overall goal
The API
The UI
Building the API
The HTTP server and routing
Co-routines as handlers
The create chat handler
The join chat handler
The load chat handler
The send message handler．
Static handlers
Building the UI
Talking to the API
Implementing the HTML
DOM events and manipulation
Adding an API worker
Additions and improvements
Clustering the API
Cleaning up chats
Asynchronous entry points
Who's typing?
Leaving chats
Polling timeouts
Summary
Index
書(shū)單推薦
