Delphi Event-based and Asynchronous Programming

Description

Event-based programming is everywhere. Nowadays, you can hardly write any kind of application without leaning on events and messages.This simple, yet extremely powerful mechanism is also the cornerstone of asynchronous and multithreaded programming. Without events, we would not know when some task was completed.But, asynchronous and multithreaded programming consists of more than just handling multiple threads, protecting shared resources, and synchronization. It also includes designing and understanding program flow. That design aspect is often forgotten, taken for granted, and solving all the fine-grained nuances of multithreaded programming hogs the spotlight.Without understanding asynchronous flow and the bigger picture it can be hard to properly solve all the other issues, including multithreading. What used to be plain spaghetti code, now becomes temporal spaghetti.You can lose control over your objects, have bits of code creating and releasing them all over the place, even without adding multithreading into the mix. Memory leaks, crashes, and holding references to dead data long after its destruction are perfectly possible even in a singlethreaded environment.While the starting point of this book is giving a proper introduction to event-based and asynchronous programming flow and design, it also provides the necessary implementation details, explanations and code examples needed to put those designs into practice. Introduction Acknowledgements Code Part 1. The Loop Hidden complexity Peeking at the console Main event loop Event-based programming Pushmi-pullyu When does pushing happen? What about polling? Game loop Part 2. Messaging Systems Windows Messaging System Windows Message Queue Posting and sending messages Message priority Custom messages Windows Messaging System in VCL Window recreation Window for non-visual components Message handler inheritance Custom messaging systems and patterns System.Messaging Part 3. Life, the Universe, and Everything Life, the Universe, and Everything Automatic memory management Interfaces Mixing object and interface references Storing an instance reference in a object reference Constructing an instance without assignment to any reference In-place construction in a const parameter Using an inline variable with type inference Interfaces and generics Class helpers Where class helpers help? Interfaces don't have helpers Generics don't have helpers Anonymous methods and lambdas What exactly is an anonymous method? What is it good for? How are anonymous methods implemented? Anonymous method variable capture Capturing and loops Anonymous method reference cycles Using weak references to break anonymous method reference cycles Part 4. Asynchronous Programming and Multithreading Asynchronous programming and multithreading Making the first dive… Application.ProcessMessages Application.ProcessMessages reentrancy problem Moving long operations to a background thread Using an anonymous thread Extending the TThread class Thread reentrancy OnTerminate event handler Handling thread exceptions Canceling the task Passing the data Pitfalls Asynchronous message dialog Tasks Thread pool Managing task lifetime Waiting for task Handling task exceptions Canceling the task Passing the data Parallel Join & For Task continuation Back to the Future What is a future There is no Future like your own Future Generic approach to future TValue approach to future Part 5. Thread safety What is thread safety anyway? Wrong assumptions Working example of thread-unsafe code The importance of thread safety Achieving thread safety General thread safety considerations Memory allocation and deallocation Object construction and destruction Assignment thread safety What does atomic mean? Atomic does not imply thread-safe Reference assignments Use immutable data Avoiding shared data Use only local data Use thread-local data Initialization pattern Protecting shared data Synchronization primitives (objects) Thread synchronization Locks No lock Recursive lock Exclusive lock Readers-writer or multi-reader lock Spinlocks Monitor Events Atomic (interlocked) operations Part 6. GUI and Multithreading Main (GUI) thread Communicating with the main thread Synchronization with the main thread Updating UI after the task is completed Updating progress counter or description Iteratively creating and populating GUI controls while task is running Speeding up GUI controls Using messaging systems Using System.Messaging Using a thread-safe messaging system Communication and GUI issues Deadlocking the main thread Deadlock with two shared resources Deadlock with shared resource and Synchronize Deadlock with waiting for a thread and Synchronize Cleanup on GUI destruction Don't destroy the GUI Use guardian interface to prevent access to destroyed GUI Using messaging systems Waiting for a thread Final notes Appendix References Quality Portal Reports