Extreme C
Taking you to the limit in Concurrency, OOP, and the most advanced capabilities of C
Kamran Amini
- 822 pages
- English
- ePUB (mobile friendly)
- Available on iOS & Android
Extreme C
Taking you to the limit in Concurrency, OOP, and the most advanced capabilities of C
Kamran Amini
About This Book
Push the limits of what C - and you - can do, with this high-intensity guide to the most advanced capabilities of C
Key Features
- Make the most of C's low-level control, flexibility, and high performance
- A comprehensive guide to C's most powerful and challenging features
- A thought-provoking guide packed with hands-on exercises and examples
Book Description
There's a lot more to C than knowing the language syntax. The industry looks for developers with a rigorous, scientific understanding of the principles and practices. Extreme C will teach you to use C's advanced low-level power to write effective, efficient systems. This intensive, practical guide will help you become an expert C programmer.
Building on your existing C knowledge, you will master preprocessor directives, macros, conditional compilation, pointers, and much more. You will gain new insight into algorithm design, functions, and structures. You will discover how C helps you squeeze maximum performance out of critical, resource-constrained applications.
C still plays a critical role in 21st-century programming, remaining the core language for precision engineering, aviations, space research, and more. This book shows how C works with Unix, how to implement OO principles in C, and fully covers multi-processing.
In Extreme C, Amini encourages you to think, question, apply, and experiment for yourself. The book is essential for anybody who wants to take their C to the next level.
What you will learn
- Build advanced C knowledge on strong foundations, rooted in first principles
- Understand memory structures and compilation pipeline and how they work, and how to make most out of them
- Apply object-oriented design principles to your procedural C code
- Write low-level code that's close to the hardware and squeezes maximum performance out of a computer system
- Master concurrency, multithreading, multi-processing, and integration with other languages
- Unit Testing and debugging, build systems, and inter-process communication for C programming
Who this book is for
Extreme C is for C programmers who want to dig deep into the language and its capabilities. It will help you make the most of the low-level control C gives you.
Frequently asked questions
Information
Chapter 18
Process Synchronization
- Firstly, we describe multi-process software where all processes are being run on the same machine. We introduce the techniques that are available in single-host environments. We use the knowledge from the previous chapter in order to give some examples that demonstrate these techniques.
- In our first attempt to synchronize a number of processes, we use named POSIX semaphores. We explain how they should be used and then we give an example that resolves a race condition issue we encountered in the previous chapters.
- After that, we talk about named POSIX mutexes and we show how we can use shared memory regions to have named mutexes up and working. As an example, we solve the same race condition resolved by semaphores, this time using named mutexes.
- As the last technique to synchronize a number of processes, we discuss named POSIX condition variables. Like named mutexes, they need to be put in a shared memory region to become accessible to a number of processes. We give a thorough example regarding this technique which shows how named POSIX condition variables can be used to synchronize a multi-process system.
- As our final discussion in this chapter, we briefly talk about the multi-process systems which have their own processes distributed around a network. We discuss their features and the problematic differences that they have in comparison to a single-host multi-process system.
Single-host concurrency control
- Named POSIX semaphores: The same POSIX semaphores that we explained in Chapter 16, Thread Synchronization, but with one difference: they have a name now and can be used globally throughout the system. In other words, they are not anonymous or private semaphores anymore.
- Named mutexes: Again, the same POSIX mutexes with the same properties which were explained in Chapter 16, Thread Synchronization, but now named and can be used throughout the system. These mutexes should be placed inside a shared memory in order to be available to multiple processes.
- Named condition variables: The same POSIX condition variables which we explained in Chapter 16, Thread Synchronization, but like mutexes, they should be placed inside a shared memory object in order to be available to a number of processes.