Mastering Concurrency in Go -- Table of Contents -- Mastering Concurrency in Go -- Credits -- About the Author -- About the Reviewers -- www.PacktPub.com -- Support files, eBooks, discount offers, and more -- Why subscribe? -- Free access for Packt account holders -- Preface -- What this book covers -- What you need for this book -- Who this book is for -- Conventions -- Reader feedback -- Customer support -- Downloading the example code -- Errata -- Piracy -- Questions -- 1. An Introduction to Concurrency in Go -- Introducing goroutines -- A patient goroutine -- Implementing the defer control mechanism -- Using Go's scheduler -- Using system variables -- Understanding goroutines versus coroutines -- Implementing channels -- Channel-based sorting at the letter capitalization factory -- Cleaning up our goroutines -- Buffered or unbuffered channels -- Using the select statement -- Closures and goroutines -- Building a web spider using goroutines and channels -- Summary -- 2. Understanding the Concurrency Model -- Understanding the working of goroutines -- Synchronous versus asynchronous goroutines -- Designing the web server plan -- Visualizing concurrency -- RSS in action -- An RSS reader with self diagnostics -- Imposing a timeout -- A little bit about CSP -- The dining philosophers problem -- Go and the actor model -- Object orientation -- Demonstrating simple polymorphism in Go -- Using concurrency -- Managing threads -- Using sync and mutexes to lock data -- Summary -- 3. Developing a Concurrent Strategy -- Applying efficiency in complex concurrency -- Identifying race conditions with race detection -- Using mutual exclusions -- Exploring timeouts -- Importance of consistency -- Synchronizing our concurrent operations -- The project - multiuser appointment calendar -- Visualizing a concurrent pattern -- Developing our server requirements.

Web server -- The Gorilla toolkit -- Using templates -- Time -- Endpoints -- Custom structs -- A multiuser Appointments Calendar -- A note on style -- A note on immutability -- Summary -- 4. Data Integrity in an Application -- Getting deeper with mutexes and sync -- The cost of goroutines -- Working with files -- Getting low - implementing C -- Touching memory in cgo -- The structure of cgo -- The other way around -- Getting even lower - assembly in Go -- Distributed Go -- Some common consistency models -- Distributed shared memory -- First-in-first-out - PRAM -- Looking at the master-slave model -- The producer-consumer problem -- Looking at the leader-follower model -- Atomic consistency / mutual exclusion -- Release consistency -- Using memcached -- Circuit -- Summary -- 5. Locks, Blocks, and Better Channels -- Understanding blocking methods in Go -- Blocking method 1 - a listening, waiting channel -- Sending more data types via channels -- Creating a function channel -- Using an interface channel -- Using structs, interfaces, and more complex channels -- The net package - a chat server with interfaced channels -- Handling direct messages -- Examining our client -- Blocking method 2 - the select statement in a loop -- Cleaning up goroutines -- Blocking method 3 - network connections and reads -- Creating channels of channels -- Pprof - yet another awesome tool -- Handling deadlocks and errors -- Summary -- 6. C10K - A Non-blocking Web Server in Go -- Attacking the C10K problem -- Failing of servers at 10,000 concurrent connections -- Using concurrency to attack C10K -- Taking another approach -- Building our C10K web server -- Benchmarking against a blocking web server -- Handling requests -- Routing requests -- Serving pages -- Parsing our template -- External dependencies -- Connecting to MySQL -- Multithreading and leveraging multiple cores.

Exploring our web server -- Timing out and moving on -- Summary -- 7. Performance and Scalability -- High performance in Go -- Getting deeper into pprof -- Parallelism's and concurrency's impact on I/O pprof -- Using the App Engine -- Distributed Go -- Types of topologies -- Type 1 - star -- Type 2 - mesh -- The Publish and Subscribe model -- Serialized data -- Remote code execution -- Other topologies -- Message Passing Interface -- Some helpful libraries -- Nitro profiler -- Heka -- GoFlow -- Memory preservation -- Garbage collection in Go -- Summary -- 8. Concurrent Application Architecture -- Designing our concurrent application -- Identifying our requirements -- Using NoSQL as a data store in Go -- MongoDB -- Redis -- Tiedot -- CouchDB -- Cassandra -- Couchbase -- Setting up our data store -- Monitoring filesystem changes -- Managing logfiles -- Handling configuration files -- Detecting file changes -- Sending changes to clients -- Checking records against Couchbase -- Backing up our files -- Designing our web interface -- Reverting a file's history - command line -- Using Go in daemons and as a service -- Checking the health of our server -- Summary -- 9. Logging and Testing Concurrency in Go -- Handling errors and logging -- Breaking out goroutine logs -- Using the LiteIDE for richer and easier debugging -- Sending errors to screen -- Logging errors to file -- Logging errors to memory -- Using the log4go package for robust logging -- Panicking -- Recovering -- Logging our panics -- Catching stack traces with concurrent code -- Using the runtime package for granular stack traces -- Summary -- 10. Advanced Concurrency and Best Practices -- Going beyond the basics with channels -- Building workers -- Implementing nil channel blocks -- Using nil channels -- Implementing more granular control over goroutines with tomb -- Timing out with channels.

Building a load balancer with concurrent patterns -- Choosing unidirectional and bidirectional channels -- Using receive-only or send-only channels -- Using an indeterminate channel type -- Using Go with unit testing -- GoCheck -- Ginkgo and Gomega -- Using Google App Engine -- Utilizing best practices -- Structuring your code -- Documenting your code -- Making your code available via go get -- Keeping concurrency out of your packages -- Summary -- Index.