Multi-threading and Single-threading performance issues in CPU-bound task

Question

The two following single-threading and multi-threading scripts are taking the same time when I give as input a big number like 555550000

single thread

import threading, time
a=[]
def print_factors(x):
   for i in range(1, x + 1):
       if x % i == 0:
           a.append(i)

n=int(input("Please enter a large number"))
print ("Starting time is %s" % ( time.ctime(time.time()) ))
print("The factors of",n,"are:")
thread = threading.Thread(target=print_factors,args=(n,))
thread.start()
thread.join()
print("Finishing time is %s" % (time.ctime(time.time())))
print(a)

multi thread

import threading, time
a=[]
def print_factors1(x):
   for i in range(1, int(x/2)):
       if x % i == 0:
           a.append(i)

def print_factors2(x):
    for i in range(int(x/2), x+1):
        if x % i == 0:
            a.append(i)

n=int(input("Please enter a large number"))
print ("Starting time is %s" % ( time.ctime(time.time()) ))
thread1 = threading.Thread(target=print_factors1,args=(n,))
thread2 = threading.Thread(target=print_factors2,args=(n,))
print("The factors of",n,"are:")
thread1.start()
thread2.start()
thread2.join()
print("Finishing time is %s" % (time.ctime(time.time())))
print(a)

I am trying to understand the difference between single-threading and multi-threading in terms of time taken to got the results.
I'm measuring similar timings for both types and I cannot figuring out the reasons.

Due to the GIL, you will not get an performance improvement on CPU-bound tasks. — Jan Christoph Terasa, Jun 02 '20 at 15:10
To make it clear, the problem is CPython's GIL, not multithreading in general. If you are not limited to Python, you can easily write a multithreaded program in C++, golang or Rust. — Jan Christoph Terasa, Jun 02 '20 at 18:04

score 3 · Answer 1 · answered Jun 02 '20 at 15:37

Your problem is GIL, the Global Interpreter Lock.

The Python Global Interpreter Lock or GIL, in simple words, is a mutex (or a lock) that allows only one thread to hold the control of the Python interpreter.

You can found detailed informations about GIL here (just a fast search on Google and you can find a lot more sources):

You need to change your implementation to use processes instead of threads.
I changed your script as follows:

from multiprocessing import Pool
import time
def print_factors1(x):
    a=[]
    for i in range(1, int(x/2)):
        if x % i == 0:
            a.append(i)
    return a

def print_factors2(x):
    a=[]
    for i in range(int(x/2), x+1):
        if x % i == 0:
            a.append(i)
    return a

if __name__ == '__main__':
    n=int(input("Please enter a large number"))
    pool = Pool(processes=2)
    print ("Starting time is %s" % ( time.ctime(time.time()) ))

    process1 = pool.apply_async(print_factors1,[n])
    process2 = pool.apply_async(print_factors2,[n])

    pool.close()
    pool.join()

    print("Finishing time is %s" % (time.ctime(time.time())))
    print("The factors of",n,"are:")
    print(process1.get())
    print(process2.get())

Take into account that threads share the memory, processes don't.

The thing is the assignment **asks** to use an application to show the difference between single and multithreading time, should I contact the proffesor and tell him that's not possible due to the GLI? — Aws Al-Masri, Jun 02 '20 at 15:50
You are welcome. Your code shows the difference between single and multi thread. If you need performance boost on CPU-bound tasks, you need to switch to multiprocess implementation. Take a look to the GIL and you'll have a lot of things to explain to your prof. — Yusef Maali, Jun 02 '20 at 15:53

Multi-threading and Single-threading performance issues in CPU-bound task

1 Answers1

Linked