CODEWITHSUNDEEP
pythonpython-multithreading
user9740907
user9740907

Reputation:

Why is the program execution time the same as before?

For some reason, the execution time is still the same as without threading.

But if I add something like time.sleep(secs) there clearly is threading in work inside the target def d.

def d(CurrentPos, polygon, angale, id):

    Returnvalue = 0
    lock = True
    steg = 0.0005
    distance = 0
    x = 0
    y = 0

    while lock == True:
        x = math.sin(math.radians(angale)) * distance + CurrentPos[0]
        y = math.cos(math.radians(angale)) * distance + CurrentPos[1]
        Localpoint = Point(x, y)
        inout = polygon.contains(Localpoint)
        distance = distance + steg
        if inout == False:
            lock = False

    l = LineString([[CurrentPos[0], CurrentPos[1]],[x,y]])
    Returnvalue = list(l.intersection(polygon).coords)[0]
    Returnvalue = calculateDistance(CurrentPos[0], CurrentPos[1], 
    Returnvalue[0], Returnvalue[1])

    with Arraylock:
        ReturnArray.append(Returnvalue)
        ReturnArray.append(id)



def Main(CurrentPos, Map):

    threads = []
    for i in range(8):
        t = threading.Thread(target = d, name ='thread{}'.format(i), args = 
        (CurrentPos, Map, angales[i], i))
        threads.append(t)
        t.start()
    for i in threads:
        i.join()

Upvotes: 1

Views: 45

Answers (1)

freakish
freakish

Reputation: 56467

Welcome to the world of the Global Interpreter Lock a.k.a. GIL. Your function looks like a CPU bound code (some calculations, loops, ifs, memory access, etc.). You can't use threads to increase performance of CPU bound tasks, sorry. It is Python's limitation.

There are functions in Python that release GIL, e.g. disk i/o, network i/o and the one you've actually tried: sleep. And indeed, threads do increase performance of i/o bound tasks. But arithmetic and/or memory access won't run parallely in Python.

The standard workaround is to use processes instead of threads. But this is often painful due to not-that-easy interprocess communication. You may also want to consider using some low level libraries like numpy that actually releases GIL in certain situations (you can only do that at C level, GIL is not accessible from Python itself) or using some other language without this limitation, e.g. C#, Java, C, C++ and so on.

Upvotes: 2

Related Questions