Multicore
A multi-core processor is an integrated circuit with two or more processors connected to it for faster simultaneous processing of several tasks, reduced power consumption, and for greater performance. Generally, it is made up of two or more processors that read and execute program instructions.
In other words, on a single chip, a multi-core processor comprises numerous processing units, or "Cores," each of which has the potential to do distinct tasks. For instance, if you are performing many tasks at once, such as watching a movie and using WhatsApp, one core will handle activities like watching a movie while the other handles other responsibilities like WhatsApp.
Architecture of Multicore Processor
A multi-core processor's design enables the communication between all available cores, and they divide and assign all processing duties appropriately. The processed data from each core is transmitted back to the computer's main board (Motherboard) via a single common gateway once all of the processing operations have been finished. This method beats a single-core CPU in terms of total performance.
Advantages of Multi-Core Processor
Performance
Reliability
Software Interactions
Multitasking
Power Consumption
Obsolescence Avoidance
Isolation
Multithreading
Multithreading allows the application to divide its task into individual threads. In multi-threads, the same process or task can be done by the number of threads, or we can say that there is more than one thread to perform the task in multithreading. With the use of multithreading, multitasking can be achieved. Multithreading can also handle multiple requests from the same user.
The main drawback of single threading systems is that only one task can be performed at a time, so to overcome the drawback of this single threading, there is multithreading that allows multiple tasks to be performed.
In the above example, client1, client2, and client3 are accessing the web server without any waiting. In multithreading, several tasks can run at the same time.
In an operating system, threads are divided into the user-level thread and the Kernel-level thread. User-level threads handled independent form above the kernel and thereby managed without any kernel support. On the opposite hand, the operating system directly manages the kernel-level threads. Nevertheless, there must be a form of relationship between user-level and kernel-level threads.
There exists three established multithreading models classifying these relationships are:
