JavaScript并发编程 (加)亚当·布达奇(Adam Boduch) 著 著作 mobi 百度云 txt pdb 下载 lrf pdf 地址

JavaScript已经具备了并发能力，这也解释了为什么这门语言至今仍然屹立于现代web开发的前沿阵地。本书将帮助你深入JavaScript并发编程的世界，演示如何应用其核心原理、关键技术以及工具来应对各种复杂的开发难题。围绕并发编程的三个核心要素：并发、同步和保护（conservation），你将学会如何编写更高效、更富于变化的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 s

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

暂无相关内容，正在全力查找中

暂无出版社相关信息，正在全力查找中！

暂无相关书籍摘录，正在全力查找中！

在线阅读地址：JavaScript并发编程 (加)亚当·布达奇(Adam Boduch) 著 著作在线阅读

在线听书地址：JavaScript并发编程 (加)亚当·布达奇(Adam Boduch) 著 著作在线收听

在线购买地址：JavaScript并发编程 (加)亚当·布达奇(Adam Boduch) 著 著作在线购买

暂无原文赏析，正在全力查找中！

书籍介绍

JavaScript已经具备了并发能力，这也解释了为什么这门语言至今仍然屹立于现代web开发的前沿阵地。亚当·布达奇编著的《JavaScript并发编程(影印版)(英文版)》将帮助你深入JavaScript并发编程的世界，演示如何应用其核心原理、关键技术以及工具来应对各种复杂的开发难题。围绕并发编程的三个核心要素：并发、同步和保护，你将学会如何编写更高效、更富于变化的JavaScript程序，从而提高用户体验。

书中通过采用各种开发方法，带领你将这些原理应用于实践。从JavaScriptpromises、webworkers、生成器到函数式编程技术，所有这些知识都将对你的应用程序性能产生实实在在的影响。除此之外，还进一步讨论了NodeJS并发编程。在成长为更优秀的Web开发人员的道路上，本书将助你一臂之力。