JavaScript并发编程
全新正版 假一赔十 可开发票
￥ 46.81 6.8折 ￥ 69 全新
仅1件
北京东城
认证卖家担保交易快速发货售后保障
作者(加)亚当·布达奇(Adam Boduch) 著 著作
出版社东南大学出版社
ISBN9787564170769
出版时间2017-04
装帧平装
开本16开
定价69元
货号1201508011
上书时间2024-12-31
商品详情
- 品相描述：全新
- 商品描述
-
目录
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
Whats available, what isnt?
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
Whos typing?
Leaving chats
Polling timeouts
Summary
Index
内容摘要
JavaScript已经具备了并发能力，这也解释了为什么这门语言至今仍然屹立于现代web开发的前沿阵地。本书将帮助你深入JavaScript并发编程的世界，演示如何应用其核心原理、关键技术以及工具来应对各种复杂的开发难题。围绕并发编程的三个核心要素：并发、同步和保护（conservation），你将学会如何编写更高效、更富于变化的JavaScript程序，提高用户体验。
相关推荐
— 没有更多了 —
以下为对购买帮助不大的评价