meta-ks/thread_priority_hack.py

## thread_priority_hack.py
import threading
import os
import signal
import time


"""
This script demonstrates the adjustment of thread priorities and handling Ctrl+C to gracefully stop threads.

Thread Priority Mechanism:
- The `thread_priority_test` function creates multiple threads with different niceness values.
- It uses the `os.nice()` function to set thread niceness, which is similar to thread priority.
- If the niceness is set to 0 (default), it attempts to set thread priority explicitly on Linux systems using the `setpriority` function.
- Each thread runs a loop until a termination signal is received (e.g., Ctrl+C).
- During the loop, it continuously updates its niceness value and maintains a dictionary of statistics.

Ctrl+C Signal Handling:
- The `signal_handler` function is set up to handle Ctrl+C signals.
- When Ctrl+C is detected, it sets the `kill_event`, signaling all threads to stop gracefully.

Usage:
- Threads are created with different niceness values (0, -2, -4).
- The script uses the `threading` module to manage threads.
- To stop the threads, press Ctrl+C, which triggers the signal handler and stops all threads.
- The statistics of thread niceness and counts are stored in the `cntr_stats_dict`.

Note:
- Thread priorities might not work on all systems, and explicit priority settings are typically limited to Unix/Linux.
- The script provides a basic demonstration of priority adjustment and signal handling.


Sample output with diff niceness:
{19: 206808916, 15: 215252820, 10: 219746028, 5: 226310260, 0: 231552779, -5: 242480906, -10: 249047980, -15: 254036155, -20: 253950489}
Niceness -20 (highest priority) enjoyed max count as it might have got more os time.
"""

# Set up a signal handler for Ctrl+C
def signal_handler(sig, frame):
    print("Ctrl+C detected. Stopping threads...")
    kill_event.set()


def thread_priority_test(tag, niceness):
    print(f'[*]Starting {tag} thread....')
    ix = 0
    os.nice(niceness)
    # if niceness == 0:
    #     setpriority(tag, linux_nice=20)

    while not kill_event.is_set():
        niceness = os.nice(0)
        ix += 1
        cntr_stats_dict[niceness] = ix


kill_event = threading.Event()
nvalues = range(0, -5, -2)
cntr_stats_dict = dict()

threads = [threading.Thread(target=thread_priority_test, args=(f'Test_{nvalue}', nvalue)) for nvalue in nvalues]

signal.signal(signal.SIGINT, signal_handler)

for thread in threads:
    thread.start()

while not kill_event.is_set():
    time.sleep(3)
    print(cntr_stats_dict)
	import threading
	import os
	import signal
	import time


	"""
	This script demonstrates the adjustment of thread priorities and handling Ctrl+C to gracefully stop threads.

	Thread Priority Mechanism:
	- The `thread_priority_test` function creates multiple threads with different niceness values.
	- It uses the `os.nice()` function to set thread niceness, which is similar to thread priority.
	- If the niceness is set to 0 (default), it attempts to set thread priority explicitly on Linux systems using the `setpriority` function.
	- Each thread runs a loop until a termination signal is received (e.g., Ctrl+C).
	- During the loop, it continuously updates its niceness value and maintains a dictionary of statistics.

	Ctrl+C Signal Handling:
	- The `signal_handler` function is set up to handle Ctrl+C signals.
	- When Ctrl+C is detected, it sets the `kill_event`, signaling all threads to stop gracefully.

	Usage:
	- Threads are created with different niceness values (0, -2, -4).
	- The script uses the `threading` module to manage threads.
	- To stop the threads, press Ctrl+C, which triggers the signal handler and stops all threads.
	- The statistics of thread niceness and counts are stored in the `cntr_stats_dict`.

	Note:
	- Thread priorities might not work on all systems, and explicit priority settings are typically limited to Unix/Linux.
	- The script provides a basic demonstration of priority adjustment and signal handling.


	Sample output with diff niceness:
	{19: 206808916, 15: 215252820, 10: 219746028, 5: 226310260, 0: 231552779, -5: 242480906, -10: 249047980, -15: 254036155, -20: 253950489}
	Niceness -20 (highest priority) enjoyed max count as it might have got more os time.
	"""

	# Set up a signal handler for Ctrl+C
	def signal_handler(sig, frame):
	print("Ctrl+C detected. Stopping threads...")
	kill_event.set()


	def thread_priority_test(tag, niceness):
	print(f'[*]Starting {tag} thread....')
	ix = 0
	os.nice(niceness)
	# if niceness == 0:
	# setpriority(tag, linux_nice=20)

	while not kill_event.is_set():
	niceness = os.nice(0)
	ix += 1
	cntr_stats_dict[niceness] = ix


	kill_event = threading.Event()
	nvalues = range(0, -5, -2)
	cntr_stats_dict = dict()

	threads = [threading.Thread(target=thread_priority_test, args=(f'Test_{nvalue}', nvalue)) for nvalue in nvalues]

	signal.signal(signal.SIGINT, signal_handler)

	for thread in threads:
	thread.start()

	while not kill_event.is_set():
	time.sleep(3)
	print(cntr_stats_dict)