Use of threading.Thread.join()
A call to thread1.join() blocks the thread in which you're making the call, until thread1 is finished. It's like wait_until_finished(thread1).
For example:
import timedef printer(): for _ in range(3): time.sleep(1.0) print "hello"thread = Thread(target=printer)thread.start()thread.join()print "goodbye"prints
hellohellohellogoodbye—without the .join() call, goodbye would come first and then 3 * hello.
Also, note that threads in Python do not provide any additional performance (in terms of CPU processing power) because of a thing called the Global Interpreter Lock, so while they are useful for spawning off potentially blocking (e.g. IO, network) and time consuming tasks (e.g. number crunching) to keep the main thread free for other tasks, they do not allow you to leverage multiple cores or CPUs; for that, look at multiprocessing which uses subprocesses but exposes an API equivalent to that of threading.
PLUG: ...and it is also for the above reason that, if you're interested in concurrency, you might also want to look into a fine library called Gevent, which essentially just makes threading much easier to use, much faster (when you have many concurrent activities) and less prone to concurrency related bugs, while allowing you to keep coding the same way as with "real" threads. Also Twisted, Eventlet, Tornado and many others, are either equivalent or comparable. Furthermore, in any case, I'd strongly suggest reading these classics:
I modified the code so that you will understand how exactly join works.so run this code with comments and without comments and observe the output for both.
val = 0def increment(msg,sleep_time): global val print "Inside increment" for x in range(10): val += 1 print "%s : %d\n" % (msg,val) time.sleep(sleep_time)thread1 = threading.Thread(target=increment, args=("thread_01",0.5))thread2 = threading.Thread(target=increment, args=("thread_02",1))thread1.start()#thread1.join()thread2.start()#thread2.join()
As the relevant documentation states, join makes the caller wait until the thread terminates.
In your case, the output is the same because join doesn't change the program behaviour - it's probably being used to exit the program cleanly, only when all the threads have terminated.