Last Updated on September 12, 2022
You can set the process name in the multiprocessing.Process class constructor or via the “name” property of the multiprocessing.Process class.
In this tutorial you will discover how to change the name of processes in Python.
Let’s get started.
Need to Change Process Name
A process is a running instance of a computer program.
Every Python program is executed in a Process, which is a new instance of the Python interpreter. This process has the name MainProcess and has one thread used to execute the program instructions called the MainThread. Both processes and threads are created and managed by the underlying operating system.
Sometimes we may need to create new child processes in our program in order to execute code concurrently.
Python provides the ability to create and manage new processes via the multiprocessing.Process class.
You can learn more about multiprocessing in the tutorial:
In concurrent programming, we may need to assign meaningful names to new processes.
This may be for many reasons such as:
- To differentiate processes while debugging.
- To differentiate processes while logging.
- To execute code conditionally on the process name.
How can we set and change process names in Python?
Run loops using all CPUs, download your FREE book to learn how.
How to Get the Process Name
We can get the name of a process via the “name” property on the multiprocessing.Process class.
For example:
|
1 2 3 |
... # report the name of the process print(process.name) |
We may get a multiprocessing.Process instance by creating a new process ourselves.
For example:
|
1 2 3 4 5 |
... # create a process process = Process() # report the name of the process print(process.name) |
Or we may acquire an instance of the multiprocessing.Process for the current process via the multiprocessing.current_process() function.
For example:
|
1 2 3 4 5 |
... # get the current process instance process = current_process() # report the name of the process print(process.name) |
It may be helpful to get the multiprocessing.Process instance for the current process from within a function or code executing in a new process so that the new process can report properties about itself, such as its name.
Now that we know how to get the name of a process, let’s look at how we might change its name.
How to Change the Process Name
The name of a process can be set when creating a new process.
The parent process will always have the name “MainProcess“.
The name of new child processes will default to the format “Process-%d“, where “%d” is an integer for the process number created by the parent process, counted from 1 sequentially up for each new child process. This means that the first new process you might create would have the name “Process-1“.
When creating a new instance of a multiprocessing.Process, we can specify the name of the process via the “name” argument.
For example:
|
1 2 3 |
... # create a process with a custom name process = Process(name='MyProcess') |
We can also configure the process name after the multiprocessing.Process instance has been created via the “name” property.
For example:
|
1 2 3 4 5 |
... # create a process with default name process = Process() # set the name process.name = 'MyProcess' |
Now that we know how to change the process name, let’s look at some worked examples.
Free Python Multiprocessing Course
Download your FREE multiprocessing PDF cheat sheet and get BONUS access to my free 7-day crash course on the multiprocessing API.
Discover how to use the Python multiprocessing module including how to create and start child processes and how to use a mutex locks and semaphores.
Example of Getting the Current Process Name
We can explore how to get the name of the current process.
First, we must acquire the multiprocessing.Process instance for the current process.
This can be achieved via the multiprocessing.current_process() function.
|
1 2 3 |
... # get the current process process = current_process() |
Once acquired, we can report the name of the process via the “name” attribute.
|
1 2 3 |
... # report a message print(f'Hello from process: {process.name}') |
Tying this together, the complete example is listed below.
|
1 2 3 4 5 6 7 |
# SuperFastPython.com # example of getting the current process name from multiprocessing import current_process # get the current process process = current_process() # report a message print(f'Hello from process: {process.name}') |
Running the example first acquires the multiprocessing.Process instance for the current process and then reports the name.
In this case, we can see that the name of the current process is “MainProcess” to indicate the main process which is the default for the Python parent process.
|
1 |
Hello from process: MainProcess |
Next, let’s look at how we might get the name of a new process.
Overwhelmed by the python concurrency APIs?
Find relief, download my FREE Python Concurrency Mind Maps
Example of Getting the Process Name
We can explore how to get the name of a new process.
First, we can define a function that will execute in a new process.
We will name the function task() and it will take no arguments.
|
1 2 3 |
# function executed in a new process def task(): # ... |
Within the function, we will first get the multiprocessing.Process instance for the process.
|
1 2 3 |
... # get the current process process = current_process() |
Then we can report a message indicating the name of the new process executing our function.
|
1 2 3 |
... # report a message print(f'Hello from a new process: {process.name}') |
Tying this together, the complete task() function is listed below.
|
1 2 3 4 5 6 |
# function executed in a new process def task(): # get the current process process = current_process() # report a message print(f'Hello from a new process: {process.name}') |
Next, in the parent process we can create a new multiprocessing.Process instance and configure it to run our new task() function via the “target” attribute.
|
1 2 3 |
... # create a new process process = Process(target=task) |
We can call the start() method on the new process which will begin executing the new child process, in turn calling the internal run() function and finally calling our task() function.
|
1 2 3 |
... # start the new process process.start() |
Finally, the parent process can block until the child process is finished.
|
1 2 3 |
... # wait for the new process to terminate process.join() |
Tying this together, the complete example of getting the process name is listed below.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
# SuperFastPython.com # example of getting the process name from multiprocessing import Process from multiprocessing import current_process # function executed in a new process def task(): # get the current process process = current_process() # report a message print(f'Hello from a new process: {process.name}') # entry point if __name__ == '__main__': # create a new process process = Process(target=task) # start the new process process.start() # wait for the new process to terminate process.join() |
Running the example first creates our new process instance then executes it.
The new process runs our task() function first acquiring the multiprocessing.Process instance of the new process executing the function, then reporting its name.
In this case, we can see that the new process used to execute our function had the default name “Process-1” for the first new child process within the Python parent process.
|
1 |
Hello from a new process: Process-1 |
Next, let’s look at how we might set a name for a new process.
Example of Setting the Process Name
We can explore how to set the name for a new process.
The name for a new process can be set via the “name” argument in the constructor to the multiprocessing.Process class when creating a new process.
We can update the example from the previous section with a task() function that gets the process instance for the process executing the function then reports the name of the process.
First, we can set the name when constructing the new process instance.
|
1 2 3 |
... # create a new process process = Process(target=task, name='Worker') |
Then the process can be started as before by calling the start() function.
|
1 2 3 |
... # start the new process process.start() |
Tying this together, the complete example of setting the process name is listed below.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
# SuperFastPython.com # example of setting the process name from multiprocessing import Process from multiprocessing import current_process # function executed in a new process def task(): # get the current process process = current_process() # report a message print(f'Hello from a new process: {process.name}') # entry point if __name__ == '__main__': # create a new process process = Process(target=task, name='Worker') # start the new process process.start() # wait until the new process has terminated process.join() |
Running the example creates the new multiprocessing.Process instance configured with a custom name and or task() function as the target function.
The process is started and the task() function acquires the process instance and reports the name, matching the name we assigned in the constructor to the class.
|
1 |
Hello from a new process: Worker |
Next, let’s look at how we might change the name of a process after it has been created.
Example of Changing the Process Name
We can explore how to change the name of a process after it has been created.
We can update the example from the previous section and change it so that the new name of the process is assigned after it is created instead of in the constructor.
We will use the same task() function that gets the process instance and reports the name of the process executing the function.
First, we can create the process as per normal, configured to execute our custom task() function.
|
1 2 3 |
... # create a new process process = Process(target=task) |
Next, we can set a custom name for the process via the “name” property.
|
1 2 3 |
... # set a custom name for the new process process.name = 'Worker' |
Finally, we can start the new process as before.
|
1 2 3 |
... # start the new process process.start() |
Tying this together, the complete example of changing the process name is listed below.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
# SuperFastPython.com # example of setting the process name via the property from multiprocessing import Process from multiprocessing import current_process # function executed in a new process def task(): # get the current process process = current_process() # report a message print(f'Hello from a new process: {process.name}') # entry point if __name__ == '__main__': # create a new process process = Process(target=task) # set a custom name for the new process process.name = 'Worker' # start the new process process.start() # wait until the new process has terminated process.join() |
Running the example creates the process, sets a new name for the process, then starts executing.
The new process runs the task() function that gets the current process instance and reports the process name.
We can see that the name of the process reported matches the name that we set after the process was created.
|
1 |
Hello from a new process: Worker |
Next, let’s look at an example of changing the process name after the process is already running.
Example of Changing the Process Name While Running
We can explore how to change the name of a process after the process is already running.
We will update the example from the previous section that sets the name of the process after the process was constructed. We can then update the task() function to get the process instance and report this name, then change the name and report the new name.
First, let’s update the task() function.
|
1 2 3 |
# function executed in a new process def task(): # ... |
The task function is defined as before, first getting the multiprocessing.Process instance and reporting the custom name.
|
1 2 3 4 5 |
... # get the current process process = current_process() # report a message print(f'Hello from a new process: {process.name}') |
Next, from within the task() function that will be executed by the process, will change the name to ‘BestWorker‘, then report this new name.
|
1 2 3 4 5 |
... # change the name (while running) process.name = 'BestWorker' # report a message print(f'Hello again, this time from: {process.name}') |
Tying this together, the complete updated task() function is listed below.
|
1 2 3 4 5 6 7 8 9 10 |
# function executed in a new process def task(): # get the current process process = current_process() # report a message print(f'Hello from a new process: {process.name}') # change the name (while running) process.name = 'BestWorker' # report a message print(f'Hello again, this time from: {process.name}') |
Finally, we can create the new process, set a custom name and start it as we did previously.
|
1 2 3 4 5 6 7 8 9 |
... # create a new process process = Process(target=task) # set a custom name for the new process process.name = 'Worker' # start the new process process.start() # wait until the new process has terminated process.join() |
Tying this together, the complete example of changing the process name while the process is running is listed below.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
# SuperFastPython.com # example of setting the process name via the property from multiprocessing import Process from multiprocessing import current_process # function executed in a new process def task(): # get the current process process = current_process() # report a message print(f'Hello from a new process: {process.name}') # change the name (while running) process.name = 'BestWorker' # report a message print(f'Hello again, this time from: {process.name}') # entry point if __name__ == '__main__': # create a new process process = Process(target=task) # set a custom name for the new process process.name = 'Worker' # start the new process process.start() # wait until the new process has terminated process.join() |
Running the example first creates a new process, configures it with a custom name then starts executing our custom task() function.
The task() function first acquires the multiprocessing.Process instance of the process that is executing itself and reports the process name. This matches the name assigned after the multiprocessing.Process instance was created.
Next, the task() function changes the name of the process, while it is running, and reports the new name. This matches the changed name.
This example shows that we can dynamically change the name of a process while it is running, from within code that the process is executing.
|
1 2 |
Hello from a new process: Worker Hello again, this time from: BestWorker |
Further Reading
This section provides additional resources that you may find helpful.
Python Multiprocessing Books
- Python Multiprocessing Jump-Start, Jason Brownlee (my book!)
- Multiprocessing API Interview Questions
- Multiprocessing API Cheat Sheet
I would also recommend specific chapters in the books:
- Effective Python, Brett Slatkin, 2019.
- See: Chapter 7: Concurrency and Parallelism
- High Performance Python, Ian Ozsvald and Micha Gorelick, 2020.
- See: Chapter 9: The multiprocessing Module
- Python in a Nutshell, Alex Martelli, et al., 2017.
- See: Chapter: 14: Threads and Processes
Guides
- Python Multiprocessing: The Complete Guide
- Python Multiprocessing Pool: The Complete Guide
- Python ProcessPoolExecutor: The Complete Guide
APIs
References
Takeaways
You now know how to change the name of processes in Python.
Do you have any questions?
Ask your questions in the comments below and I will do my best to answer.
Photo by Karsten Gohm on Unsplash
Do you have any questions?