Why multithreading in c

Secondly, and often more importantly, it allows the programmer to divide each particular job of a program up into its own piece that operates independently of all the others. A media player, for example, can have a thread for pre-buffering the incoming media, possibly from a harddrive, CD , DVD , or network socket, a thread to process user input, and a thread to play the actual media.

A stall in any single thread won't keep the others from doing their jobs. For the operating system, switching between threads is normally cheaper than switching between processes. This is because the memory management information doesn't change between threads, only the stack and register set do, which means less data to copy on context switches.

Multithreading — Basic Concepts Multithreaded applications often require synchronization objects. These objects are used to protect memory from being modified by multiple threads at the same time, which might make the data incorrect. The first, and simplest, is an object called a mutex. A mutex is like a lock.

A thread can lock it, and then any subsequent attempt to lock it, by the same thread or any other, will cause the attempting thread to block until the mutex is unlocked. These are very handy for keeping data structures correct from all the threads' points of view. For example, imagine a very large linked list. If one thread deletes a node at the same time that another thread is trying to walk the list, it is possible for the walking thread to fall off the list, so to speak, if the node is deleted or changed.

Using a mutex to "lock" the list keeps this from happening. Computer Scientist people will tell you that Mutex stands for Mut ual Ex clusion. In Java , Mutex-like behaviour is accomplished using the synchronized keyword. Technically speaking, only the thread that locks a mutex can unlock it, but sometimes operating systems will allow any thread to unlock it.

Doing this is, of course, a Bad Idea. If you need this kind of functionality, read on about the semaphore in the next paragraph. Similar to the mutex is the semaphore. A semaphore is like a mutex that counts instead of locks. If it reaches zero, the next attempt to access the semaphore will block until someone else increases it. This is useful for resource management when there is more than one resource, or if two separate threads are using the same resource in coordination.

Common terminology for using semaphores is "uping" and "downing", where upping increases the count and downing decreases and blocks on zero. Java provides a Class called Semaphore which does the same thing, but uses acquire and release methods instead of uping and downing.

With a name as cool-sounding as semaphore , even Computer Scientists couldn't think up what this is short for. Yes, I know that a semaphore is a signal or flag ; Unlike mutexes , semaphores are designed to allow multiple threads to up and down them all at once.

If you create a semaphore with a count of 1, it will act just like a mutex , with the ability to allow other threads to unlock it. The third and final structure is the thread itself. More specifically, thread identifiers. A simple C program to demonstrate use of pthread basic functions Please note that the below program may compile only with C compilers with pthread library.

The second argument specifies attributes. If the value is NULL, then default attributes shall be used. The third argument is name of function to be executed for the thread to be created.

The fourth argument is used to pass arguments to the function, myThreadFun. How to compile above program? To compile a multithreaded program using gcc, we need to link it with the pthreads library. Following is the command used to compile the program. Global and static variables are stored in data segment. Therefore, they are shared by all threads. The following example program demonstrates the same. Accessing a global variable in a thread is generally a bad idea.

What if thread 2 has priority over thread 1 and thread 1 needs to change the variable. In practice, if it is required to access global variable by multiple threads, then they should be accessed using a mutex.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. Skip to content. Multithreading creates a process that consists of multiple threads of execution thread. It is used when the parallel execution of some tasks leads to more efficient use of resources of the system.

Multithreading is a natural choice for handling event-driven code which is mostly common in today's highly distributed, networked, GUI-based environments. It can be applied to one process to enable parallel execution on a multiprocessing system. What is Thread? Thread is the smallest sequence of programming instructions that can be managed by a scheduler.

It is a dispatchable unit of executable code. These threads can run parallel and increases efficiency of programs. Each part of a program is called a Thread , and each thread defines a separate part of execution.

If thread is in need of more than one resource then it requires more than one lock and it is possible to use more locks. If any lock is not available, the thread will wait or block on the lock.

Process is an instance of a running program. System resources such as CPU time, memory etc. Each process is an independent entity and communicates with each other through inter-process communication.

Process provides two key abstractions such as Logical control flow CPU and Private virtual address space Main memory for each process.