JavaScript并发编程（影印版）

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