파이썬 쓰레드(Thread)Python Threads

Software often has to handle several tasks at the same time. To do that, it’s important to understand the concepts of programs, processes, and threads.

Program

Generally, a program is a set of instructions stored in a static state on a disk such as a hard disk drive (HDD) or SSD. By ‘static state,’ I mean code that isn’t running.

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'lineColor': '#2196f3',
      'primaryTextColor': '#fff',
      'tertiaryColor': '#333'
    }
  }
}%%
flowchart LR
    subgraph "Hard Disk"
        Program[Program]
    end

So what does the ‘running’ state mean? Let’s look at what happens when a program runs.

Process

When a program runs, it’s given its own separate memory space and becomes ready for the CPU to process its instructions. This state is called a ‘process.’

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'lineColor': '#2196f3',
      'primaryTextColor': '#fff',
      'tertiaryColor': '#333'
    }
  }
}%%
flowchart LR
    subgraph "Hard Disk"
        Program[Program]
    end

    subgraph "Memory"
        Process[Process]
    end

    Program --- Process

The Chrome Browser

The Chrome browser uses a multi-process model, where each tab runs as its own process. Because each tab runs independently, even if one tab hits an error, the other tabs keep working reliably.

> One tab is acting up, but it's no big deal

Characteristics of a Process

Process Memory Layout

Each process is given its own separate memory space, as shown below. So even if one process terminates abnormally, it doesn’t affect the others, and they keep running reliably.

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'lineColor': '#2196f3',
      'primaryTextColor': '#fff',
      'tertiaryColor': '#333'
    }
  }
}%%
flowchart LR
    subgraph "Hard Disk"
        Program[Chrome.exe]
    end

    subgraph "Memory"
        Process1[Chrome Tab A]
        Process2[Chrome Tab B]
    end

    Program --- Process1
    Program --- Process2

A process divides its memory into four main sections.

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'lineColor': '#2196f3',
      'primaryTextColor': '#000',
      'tertiaryColor': '#333'
    }
  }
}%%
flowchart TB
    subgraph "Memory"
        subgraph "Process"
            CS1[Code Section]
            DS1[Data Section]
            HS1[Heap Section]
            SS1[Stack Section]
        end
    end

    style Process fill:#555,stroke:#333,stroke-width:1px

    style CS1 fill:#bbf,stroke:#333,stroke-width:1px
    style DS1 fill:#ddf,stroke:#333,stroke-width:1px
    style HS1 fill:#ffd,stroke:#333,stroke-width:1px
    style SS1 fill:#dfd,stroke:#333,stroke-width:1px

• Code Section : The executable code
• Data Section : Global and static variables
• Heap Section : Dynamically allocated memory
• Stack Section : Local variables and function call information

IPC (Inter-Process Communication)

Because processes run independently, the various ways they communicate with each other are called IPC (Inter-Process Communication). Methods include pipes, sockets, shared memory, and message queues. This communication can introduce some overhead.

PCB (Process Control Block)

A data structure called the PCB (Process Control Block) is created for each process. The PCB stores various information about the process.

• Process ID
• Process state
• Program counter
• CPU registers, etc.

Based on this information, each process is allocated system resources such as CPU time and memory.

Thread

A process is the state in which a program has been given memory and can execute instructions. So who actually executes the instructions in a process? That’s the job of a thread.

thread

1. a thin strand of yarn
2. a line (of a story or argument)
3. to thread (a needle, etc.)

A thread is a small unit of execution that runs inside a process. As the word suggests, you can think of it as a “thread of execution” or a “flow of control.” Every process contains at least one thread.

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'lineColor': '#2196f3',
      'primaryTextColor': '#000',
      'tertiaryColor': '#333'
    }
  }
}%%
flowchart BT
    subgraph "Memory"
        subgraph "Process"
            T11[Thread 1]
            CODE1[code]
            CODE2[code]
        end
    end

    T11 --- CODE1
    CODE1 --- CODE2

    style Process fill:#555,stroke:#333,stroke-width:1px

    style T11 fill:#fff,stroke:#333,stroke-width:1px
    style CODE1 fill:#bbf,stroke:#333,stroke-width:1px
    style CODE2 fill:#bbf,stroke:#333,stroke-width:1px

How Threads Share Resources

Suppose there are two threads in a single process. Each thread gets its own stack, and the rest of the memory space is shared within the process.

flowchart TB
    subgraph CPU["CPU"]
        Registers["Registers"]
    end

    subgraph Process["Process"]
        subgraph Shared["Shared memory"]
            direction TB
            Code["Code section
(program code)"]
            Data["Data section
(global/static variables)"]
            Heap["Heap section
(dynamically allocated memory)"]
        end

        subgraph ThreadStacks["Per-thread stacks"]
            Stack1["Thread 1 Stack"]
            Stack2["Thread 2 Stack"]
        end
    end

    %% Style definitions
    style Process fill:#555,stroke:#333,stroke-width:1px,color:#bbb

    classDef cpu fill:#ffcdd2,stroke:#d32f2f,stroke-width:2px
    classDef shared fill:#e1f5fe,stroke:#0288d1,stroke-width:2px
    classDef thread fill:#e8f5e9,stroke:#4caf50,stroke-width:2px
    classDef process fill:#f5f5f5,stroke:#333,stroke-width:2px

    class CPU cpu
    class Shared shared
    class ThreadContexts,ThreadStacks thread
    class Process process

A single CPU core can execute only one thread at any given moment. So even when several threads seem to run at the same time, they’re actually taking turns very quickly.

Context Switching

Context switching means pausing the currently running process/thread and running a different one. Each time, the previous state (the context) is saved and the switch to the new state is made.

> Source : Akka in Action

Does adding more threads make things faster? Maybe, maybe not. Context switching is itself a piece of work, so if it happens too often, it becomes overhead. That’s why striking the right balance matters.

Python Threads

In Python, a process gets one thread by default. This thread is called the main thread (MainThread). Let’s look at how to create and use other threads from the main thread.

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'lineColor': '#2196f3',
      'primaryTextColor': '#000',
      'tertiaryColor': '#333'
    }
  }
}%%
flowchart BT
    subgraph "Memory"
        subgraph "Process"
            T11[Main Thread]
            T12[Sub Thread]

            CODE1[code]
            CODE2[code]
        end
    end

    T11 --- CODE1
    T12 --- CODE2

    style Process fill:#555,stroke:#333,stroke-width:1px

    style T11 fill:#fff,stroke:#333,stroke-width:1px
    style T12 fill:#fff,stroke:#333,stroke-width:1px
    style CODE1 fill:#bbf,stroke:#333,stroke-width:1px
    style CODE2 fill:#bbf,stroke:#333,stroke-width:1px

The threading Module

In Python, you can create threads with the Thread class in the built-in threading module. You start a thread with the start method.

• target : The function the thread will run
• args : Arguments passed as an iterable
• kwargs : Arguments passed as a dict

import threading

thread = threading.Thread(target=lambda x: print(f"Hello, {x}"), args=("Thread",))

thread.start()

Hello, Thread

Subclassing threading.Thread

You can define a thread class by subclassing Thread. Instead of using the target argument, you override the run method to define the work the thread will do.

import threading

class MyThread(threading.Thread):
    def __init__(self, name: str):
        super().__init__()        
        self.name = name
        
    def run(self):
        print(f"Hello, {self.name}")

if __name__ == "__main__":
    thread = MyThread("MyThread")
    thread.start()

Current Thread Information

You can check information about the current thread with the current_thread method.

• ident : The thread’s unique identifier
• name :
  • By default, shown as “Thread-number (function name)”
  • For the main thread = MainThread

import threading as th

def sub_thread():
    print(f"{th.current_thread().name} : {th.current_thread().ident}")

thread1 = th.Thread(target=sub_thread)
thread2 = th.Thread(target=sub_thread)

if __name__ == "__main__":
    thread1.start()
    thread2.start()

    print(f"{th.current_thread().name} Done")

Thread-1 (sub_thread) : 139696827188800
Thread-2 (sub_thread) : 140045886248512
MainThread Done

Thread Concurrency

Threads have the property of concurrency: they take turns running. They don’t actually run at the same time; the CPU switches between threads so quickly that it looks that way.

If you run the code below, the order in which the main thread and the sub thread run may differ each time, and that’s determined by the operating system’s scheduler.

import threading as th

def print_numbers(i: int):
    for j in range(1, i + 1):
        print(f"Sub Thread : {j}")

thread1 = th.Thread(target=print_numbers, args=(100,))

if __name__ == "__main__":
    thread1.start()
    print("MainThread Done")

Sub Thread : 6
Sub Thread : 7
...
MainThread Done
...
Sub Thread: 100

The join Method

Let’s look at the join method, which makes a thread wait until another thread finishes. It’s handy for controlling the order of work or handling tasks that depend on each other.

import threading as th

def print_numbers(i: int):
    for j in range(1, i + 1):
        print(f"Sub Thread : {j}")

sub_thread = th.Thread(target=print_numbers, args=(100,))

if __name__ == "__main__":
    sub_thread.start()
    sub_thread.join()

    print("MainThread Done")

With the join method, you can see that the main thread (MainThread) waits until the sub thread (Sub Thread) finishes its work, and only then prints the Done message.

...
Sub Thread : 99
Sub Thread : 100
MainThread Done

If you want to run several threads one after another, you can do it like this. You’ll see that thread2 starts its work only after thread1 has completely finished.

if __name__ == "__main__":
    thread1.start()
    thread1.join()

    thread2.start()
    thread2.join()
    print("MainThread Done")

Daemon Threads

A daemon thread is a background thread that ends when the main thread ends. It’s mainly used for work that supports the main thread. You create one by setting the daemon argument on a regular thread.

daemon_thread = th.Thread(target=background_task, daemon=True)

import threading as th
import time

def background_task():
    while True:
        print("Daemon thread is running...")
        time.sleep(1)

daemon_thread = th.Thread(target=background_task, daemon=True)

if __name__ == "__main__":
    daemon_thread.start()
    print("Main thread is running...")
    time.sleep(3)
    print("Main thread is ending...")

Main thread is running...
Daemon thread is running...
Daemon thread is running...
Daemon thread is running...
Main thread is ending...
Daemon thread is running...

The is_alive Method

You can use the is_alive method to check whether a thread is currently running. It’s useful for one thread to monitor what another thread is doing, and especially handy for debugging and logging.

Example: Monitoring

import threading as th
import time

def monitor_thread(thread_to_monitor: th.Thread):
    while thread_to_monitor.is_alive():
        print(f"Monitoring: {thread_to_monitor.name} is running")
        time.sleep(0.5)
    print(f"Monitoring: {thread_to_monitor.name} has finished")

def worker():
    print(f"{th.current_thread().name} started")
    time.sleep(1)
    print(f"{th.current_thread().name} finished")

if __name__ == "__main__":
    work_thread = th.Thread(target=worker, name="WorkerThread")

    monitor = th.Thread(
        target=monitor_thread, args=(work_thread,), name="MonitorThread", daemon=True
    )

    work_thread.start()
    monitor.start()

    work_thread.join()

1. Create work_thread first and pass it to the monitor thread.
2. The monitor checks whether work_thread is running with is_alive().
3. When work_thread finishes, the main thread (MainThread) ends, and so does monitor, since it’s a daemon thread.

WorkerThread started
Monitoring: WorkerThread is running
Monitoring: WorkerThread is running
WorkerThread finished
Monitoring: WorkerThread has finished

Wrapping Up

So far, we’ve covered these important concepts:

• How a program goes from an executable file to being loaded into memory as a process
• The concept of a thread, the unit of execution that does the actual work inside a process
• How to create and manage threads in Python with the threading module
• Practical thread control techniques such as join(), is_alive(), and daemon

Going Further

For more efficient and safer multithreaded programming, it would be worth studying these more advanced topics. 😊

• Mutex
• Semaphore
• Efficient task processing with ThreadPoolExecutor