Processes and Threads

• Processes are programs that are currently being executed and managed by OS.
• Processes have their own address space, memory, and stack.
• Threads are lightweight processes that can share a process with other threads and use the same context.
• Running multiple tasks simultaneously needs a non-standard Python implementation.
• A thread is an individual unit of execution within a process, can work together to achieve a common goal.
• A video game exemplifies multitasking with separate threads for graphics, user interface, and networking.
• All tasks in threads must be handled in parallel and remain responsive.
• A process contains code and local variables within each thread.
• Threads are lightweight processes, which reduce memory overhead.
• A thread represents a sequence of control flow.
• Key difference between the thread and process is that threads exist entirely inside a process and share its resources.
• A process will contain global variables, each thread can share these global variable.
• At the same time, each thread has its local variables and its code to control the flow between the local and global variables.
• A single process can have multiple threads, which is useful for applications performing concurrent tasks on shared data.
• Browsers handle landing pages, animations, multiple websites, videos, and other tasks using multiple threads, remaining responsive throughout.
• There are two types of threads: kernel threads and user threads.
• Kernel threads are part of the OS.
• User threads are not implemented in the kernel, and are seen as an extension of function concepts in programming languages.
• Multithreaded programs run faster on multi-CPU systems.
• Programs remain responsive to input in both single and multi-CPU systems.
• Threads allow I/O tasks to compute while other tasks are being performed.
• Certain programs can be more easily expressed using concurrency.
• Threads in a process can share the memory of global variables.
• To implement a thread in Python, the thread module or threading module can be used.

Thread module

• You must always first call the thread module.
• To spawn a thread, start_new_thread function is called, is available in the _thread module.
• start_new_thread enables a fast and efficient way to create new threads.
• start_new_thread starts a child thread and accepts three arguments:
• The function to execute inside the thread; If this returns, then the thread terminates.
• A tuple of arguments provided to the function which is passed by the user; Use an empty tuple if the function doesn't need arguments.
• An optional dictionary of keyword arguments.

Thread module example:

• Two threads are created to run print_time function.
• A loop with a time delay is created to see the thread execution in action.
• A mechanism to wait for the thread creation is created using while or input().

Threading module:

• Offers higher-level support for threads compared to the thread module.
• Includes a Thread class, which is used to create threads.
• The start() method will start the thread by internally calling the run() method.
• The join([time]) method will wait for threads to terminate.
• To create a new thread with the threading module
• Creates an object of the class Thread
• It take two arguments:
• target: which is the function to be executed by thread
• args: are the arguments to be passed to the target function
• Once the thread is created, invoke the start() to start a new thread.
• Call the t.join() method in order to stop execution of the current program until a thread is complete.

Threading module example 1:

• Two threads, t1 and t2, are created as objects of the thread class
• When the threads are initiated, their start time is run
• The t1.join() thread is executed completely.
• Once, it is finished, only then will thread t2.join()
• Finally, the confirmation message will print the message, "done!"

Threading module example 2:

• The cube and square of a number are printed using threads.
• There is a sleep functions used to make sure that the threads are completed successfully, but using locks is more effective.

Python and threading

• Only one thread can be executed at a time in the interpreter, and access is controlled by the Global Interpreter Lock (GIL).
• Threading occurs when a running thread either sleeps, ends, or executes a specified number of instructions.
• External code locks GIL, because the interpreter cannot count Python byte code intervals on it.

Life without threads:

• Without threads, tasks are executed sequentially, which may not be as efficient.

Thread module

• Provides low-level thread control, not recommended for most use cases.
• When with using thread modules, the program ends when the main thread ends, without waiting for child threads to complete.
• Threading module is generally preferred.

Multithreaded Solution:

• If the main thread sleeps less than child threads, the execution could terminate when the main function finishes.

Thread functions:

• threading.Thread(target=function, args=args, kwargs=kwargs).start(): Spawns a new thread, executing the function with given arguments.
• threading.Lock(): Allocates a LockType object.
• thread.exit(): Exits the thread.

LockType functions:

• aquire(wait=None): Attempts to acquire a lock.
• locked(): Returns true if the lock is acquired, otherwise returns false.
• release(): Releases the lock.
• threading.Lock() in Python creates a lock object used to synchronize thread access to a shared resource.
• A lock object has two states: locked and unlocked; it starts unlocked and can be acquired with acquire().
• Once a thread acquires a lock, it blocks other threads from acquiring it until the lock is released using release().

Using locks instead of sleep:

• Each thread will needs to aqcuire a lock
• Threads execute and release their locks.
• The program waits for all locks to be released before finishing.