Learning Concurrency in Python

1. Preface 2. What this book covers 3. What you need for this book 4. Who this book is for 5. Conventions 6. Reader feedback 7. Downloading the example code 8. Errata 9. Piracy 10. Questions 11. Speed It Up! 12. History of concurrency 13. Threads and multithreading 14. What is a thread? 15. Types of threads 16. What is multithreading? 17. Processes 18. Properties of processes 19. Multiprocessing 20. Event-driven programming 21. Turtle 22. Breaking it down 23. Reactive programming 24. ReactiveX - RxPy 25. Breaking it down 26. GPU programming 27. PyCUDA 28. OpenCL 29. Theano 30. The limitations of Python 31. Jython 32. IronPython 33. Why should we use Python? 34. Concurrent image download 35. Sequential download 36. Breaking it down 37. Concurrent download 38. Breaking it down 39. Improving number crunching with multiprocessing 40. Sequential prime factorization 41. Breaking it down 42. Concurrent prime factorization 43. Breaking it down 44. Summary 45. Parallelize It 46. Understanding concurrency 47. Properties of concurrent systems 48. I/O bottlenecks 49. Understanding parallelism 50. CPU-bound bottlenecks 51. How do they work on a CPU? 52. Single-core CPUs 53. Clock rate 54. Martelli model of scalability 55. Time-sharing - the task scheduler 56. Multi-core processors 57. System architecture styles 58. SISD 59. SIMD 60. MISD 61. MIMD 62. Computer memory architecture styles 63. UMA 64. NUMA 65. Summary 66. Life of a Thread 67. Threads in Python 68. Thread state 69. State flow chart 70. Python example of thread state 71. Breaking it down 72. Different types of threads 73. POSIX threads 74. Windows threads 75. The ways to start a thread 76. Starting a thread 77. Inheriting from the thread class 78. Breaking it down 79. Forking 80. Example 81. Breaking it down 82. Daemonizing a thread 83. Example 84. Breaking it down 85. Handling threads in Python 86. Starting loads of threads 87. Example 88. Breaking it down 89. Slowing down programs using threads 90. Example 91. Breaking it down 92. Getting the total number of active threads 93. Example 94. Breaking it down 95. Getting the current thread 96. Example 97. Breaking it down 98. Main thread 99. Example 100. Breaking it down 101. Enumerating all threads 102. Example 103. Breaking it down 104. Identifying threads 105. Example 106. Breakdown 107. Ending a thread 108. Best practice in stopping threads 109. Example 110. Output 111. Orphan processes 112. How does the operating system handle threads 113. Creating processes versus threads 114. Example 115. Breaking it down 116. Multithreading models 117. One-to-one thread mapping 118. Many-to-one 119. Many-to-many 120. Summary 121. Synchronization between Threads 122. Synchronization between threads 123. The Dining Philosophers 124. Example 125. Output 126. Race conditions 127. Process execution sequence 128. The solution 129. Critical sections 130. Filesystem 131. Life-critical systems 132. Shared resources and data races 133. The join method 134. Breaking it down 135. Putting it together 136. Locks 137. Example 138. Breaking it down 139. RLocks 140. Example 141. Breaking it down 142. Output 143. RLocks versus regular locks 144. Condition 145. Definition 146. Example 147. Our publisher 148. Our subscriber 149. Kicking it off 150. The results 151. Semaphores 152. Class definition 153. Example 154. The TicketSeller class 155. Output 156. Thread race 157. Bounded semaphores 158. Events 159. Example 160. Breaking it down 161. Barriers 162. Example 163. Breaking it down 164. Output 165. Summary 166. Communication between Threads 167. Standard data structures 168. Sets 169. Extending the class 170. Exercise - extending other primitives 171. Decorator 172. Class decorator 173. Lists 174. Queues 175. FIFO queues 176. Example 177. Breaking it down 178. Output 179. LIFO queues 180. Example 181. Breaking it down 182. Output 183. PriorityQueue 184. Example 185. Breakdown 186. Output 187. Queue objects 188. Full/empty queues 189. Example 190. Output 191. The join() function 192. Example 193. Breakdown 194. Output 195. Deque objects 196. Example 197. Breakdown 198. Output 199. Appending elements 200. Example 201. Breaking it down 202. Output 203. Popping elements 204. Example 205. Breaking it down 206. Output 207. Inserting elements 208. Example 209. Breaking it down 210. Output 211. Rotation 212. Example 213. Breaking it down 214. Output 215. Defining your own thread-safe communication structures 216. A web Crawler example 217. Requirements 218. Design 219. Our Crawler class 220. Our starting point 221. Extending the queue object 222. Breaking it down 223. Output 224. Future enhancements 225. Conclusion 226. Exercise - testing your skills 227. Summary 228. Debug and Benchmark 229. Testing strategies 230. Why do we test? 231. Testing concurrent software systems 232. What should we test? 233. Unit tests 234. PyUnit 235. Example 236. Output 237. Expanding our test suite 238. Unit testing concurrent code 239. Integration tests 240. Debugging 241. Make it work as a single thread 242. Pdb 243. An interactive example 244. Catching exceptions in child threads 245. Benchmarking 246. The timeit module 247. Timeit versus time 248. Command-line example 249. Importing timeit into your code 250. Utilizing decorators 251. Timing context manager 252. Output 253. Profiling 254. cProfile 255. Simple profile example 256. The line_profiler tool 257. Kernprof 258. Memory profiling 259. Memory profile graphs 260. Summary 261. Executors and Pools 262. Concurrent futures 263. Executor objects 264. Creating a ThreadPoolExecutor 265. Example 266. Output 267. Context manager 268. Example 269. Output 270. Maps 271. Example 272. Output 273. Shutdown of executor objects 274. Example 275. Output 276. Future objects 277. Methods in future objects 278. The result() method 279. The add_done_callback() method 280. The .running() method 281. The cancel() method 282. The .exception() method 283. The .done() method 284. Unit testing future objects 285. The set_running_or_notify_cancel() method 286. The set_result() method 287. The set_exception() method 288. Cancelling callable 289. Example 290. Output 291. Getting the result 292. Example 293. Output 294. Using as_completed 295. Example 296. Output 297. Setting callbacks 298. Example 299. Output 300. Chaining callbacks 301. Exception classes 302. Example 303. Output 304. ProcessPoolExecutor 305. Creating a ProcessPoolExecutor 306. Example 307. Output 308. Context Manager 309. Example 310. Output 311. Exercise 312. Getting started 313. Improving the speed of computationally bound problems 314. Full code sample 315. Output 316. Improving our crawler 317. The plan 318. New improvements 319. Refactoring our code 320. Storing the results in a CSV file 321. Exercise - capture more info from each page crawl 322. concurrent.futures in Python 2.7 323. Summary 324. Multiprocessing 325. Working around the GIL 326. Utilizing sub-processes 327. Example 328. Output 329. The life of a process 330. Starting a process using fork 331. Spawning a process 332. Forkserver 333. Daemon processes 334. Example 335. Breaking it down 336. Output 337. Identifying processes using PIDs 338. Example 339. Output 340. Terminating a process 341. Example 342. Getting the current process 343. Subclassing processes 344. Example 345. Output 346. Multiprocessing pools 347. The difference between concurrent.futures.ProcessPoolExecutor and Pool 348. Context manager 349. Example 350. Output 351. Submitting tasks to a process pool 352. Apply 353. Apply_async 354. Map 355. Map_async 356. Imap 357. Imap_unordered 358. Starmap 359. Starmap_async 360. Maxtasksperchild 361. Communication between processes 362. Pipes 363. Anonymous pipes 364. Named pipes 365. Working with pipes 366. Example 367. Handling Exceptions 368. Using pipes 369. Multiprocessing managers 370. Namespaces 371. Example 372. Queues 373. Example 374. Output 375. Listeners and clients 376. Example 377. The Listener class 378. The Client class 379. Output 380. Logging 381. Example 382. Communicating sequential processes 383. PyCSP 384. Processes in PyCSP 385. Output 386. Summary 387. Event-Driven Programming 388. Event-driven programming 389. The event loop 390. Asyncio 391. Getting started 392. Event loops 393. The run_forever() method 394. The run_until_complete() method 395. The stop() method 396. The is_closed() method 397. The close() function 398. Tasks 399. Example 400. The all_tasks(loop=None) method 401. The current_tasks() function 402. The cancel() function 403. Task functions 404. The as_completed(fs, *, loop=None, timeout=None) function 405. The ensure_future(coro_or_future, *, loop=None) function 406. The wrap_future(future, *, loop=None) function 407. The gather(*coroes_or_futures, loop=None, return_exceptions=False) function 408. The wait() function 409. Futures 410. Example 411. Output 412. Coroutines 413. Chaining coroutines 414. Output 415. Transports 416. Protocols 417. Synchronization between coroutines 418. Locks 419. Queues 420. Events and conditions 421. Semaphores and BoundedSemaphores 422. Sub-processes 423. Debugging asyncio programs 424. Debug mode 425. Twisted 426. A simple web server example 427. Gevent 428. Event loops 429. Greenlets 430. Simple example-hostnames 431. Output 432. Monkey patching 433. Summary 434. Reactive Programming 435. Basic reactive programming 436. Maintaining purity 437. ReactiveX, or RX 438. Installing RxPY 439. Observables 440. Creating observers 441. Example 442. Example 2 443. Breaking it down 444. Output 445. Lambda functions 446. Example 447. Breaking it down 448. On_next, on_completed, and on_error in lambda form 449. Output 450. Operators and chaining 451. Filter example 452. Breaking it down 453. Chained operators 454. The different operators 455. Creating observables 456. Transforming observables 457. Filtering observables 458. Error-handling observables 459. Hot and cold observables 460. Emitting events 461. Example 462. Breaking it down 463. Output 464. Multicasting 465. Example 466. Output 467. Combining observables 468. Zip() example 469. Output 470. The merge_all() operator 471. Output 472. Concurrency 473. Example 474. Output 475. PyFunctional 476. Installation and official docs 477. Simple example 478. Output 479. Streams, transformations, and actions 480. Filtering lists 481. Output 482. Reading/writing SQLite3 483. Compressed files 484. Parallel execution 485. Summary 486. Using the GPU 487. Basic reactive programming 488. Maintaining purity 489. ReactiveX, or RX 490. Installing RxPY 491. Observables 492. Creating observers 493. Example 494. Example 2 495. Breaking it down 496. Output 497. Lambda functions 498. Example 499. Breaking it down 500. On_next, on_completed, and on_error in lambda form 501. Output 502. Operators and chaining 503. Filter example 504. Breaking it down 505. Chained operators 506. The different operators 507. Creating observables 508. Transforming observables 509. Filtering observables 510. Error-handling observables 511. Hot and cold observables 512. Emitting events 513. Example 514. Breaking it down 515. Output 516. Multicasting 517. Example 518. Output 519. Combining observables 520. Zip() example 521. Output 522. The merge_all() operator 523. Output 524. Concurrency 525. Example 526. Output 527. PyFunctional 528. Installation and official docs 529. Simple example 530. Output 531. Streams, transformations, and actions 532. Filtering lists 533. Output 534. Reading/writing SQLite3 535. Compressed files 536. Parallel execution 537. Summary 538. Choosing a Solution 539. Libraries not covered in this book 540. GPU 541. PyGPU 542. Event-driven and reactive libraries 543. Tornado 544. Flask 545. Celery 546. Data science 547. Pandas 548. Matplotlib 549. TensorFlow 550. Designing your systems 551. Requirements 552. Functional requirements 553. Non-functional requirements 554. Design 555. Computationally expensive 556. Event-heavy applications 557. I/O-heavy applications 558. Recommended design books 559. Software Architecture with Python 560. Python: Master the Art of Design Patterns 561. Research 562. Summary