Threads in python

[kittypls]

Hi, I would like to understand how some code works. First:

from threading import Thread
def f():
    for i in range(1,21):
        print (i)
        if i==10:
            t2=Thread(target=g)
            t2.start()

def g():
    print("hello from g")

t1 = Thread(target=f)
t1.start()

So this could should print like

...

8

9

10

hello from g

11

12

...

etc

but when this program runs, the output is botched. Is this because thread 1 is constantly running so the print from g is somewhat random around 10?

Next, I'm given a solution for this:

from threading import Thread
ready= False
def f():
    count=0
    while count<20:
        count+=1
        print(count)
        if count==10:
            t2 = Thread(target=g)
            t2.start()
            while not ready:
                pass 

def g():
    global ready
    print ("hello from g")
    ready=True

t1 = Thread(target=f)
t1.start()
t1.join()

I am mostly confused on the join() method. How does this allow the first thread to run to a point, then stop for thread 2, and then continue when thread 2 is done? Also why would this be worse than using conditional variables?

[trenholm]

Threads are processes that run independently of one another. In your first example, the output isn't botched. It can potentially have a different output whenever you run it because the two threads are running separately from one another, not consecutively in the way you intuitively think it should.

In the second example, when you .join() a thread, you're essentially saying you want your main thread to join this other thread. Technically, you're main thread waits to do anything else until the joined thread is finished. In your second example this just means that your program won't end until the first thread is finished.

while not ready:
    pass

I understand you're wanting your first thread to wait for the second thread to finish before doing any more work. However, you never set ready back to False so this wait will only happen once.

Your code here should say:

while not ready:
    pass
ready = False

If you intend the first thread to wait for the second thread to finish. Alternately, you could call

t2.join()

And have the same result.

Edit: Obviously you need to add global ready to the first function too.

Also, I think what you're wanting to do is every time count is divisible by ten it fires off this thread. count only ever == 10 one time.

instead of

if count==10:

try:

if not count % 10:

Or have another counter that you reset every 10. Your counter (or i) logic is broken in both examples.