Python多线程与多进程中join()方法的效果是相同的。
下面仅以多线程为例：
首先需要明确几个概念：
知识点一：
当一个进程启动之后，会默认产生一个主线程，因为线程是程序执行流的最小单元，当设置多线程时，主线程会创建多个子线程，在python中，默认情况下（其实就是setDaemon(False)），主线程执行完自己的任务以后，就退出了，此时子线程会继续执行自己的任务，直到自己的任务结束，例子见下面一。
知识点二：
当我们使用setDaemon(True)方法，设置子线程为守护线程时，主线程一旦执行结束，则全部线程全部被终止执行，可能出现的情况就是，子线程的任务还没有完全执行结束，就被迫停止，例子见下面二。
知识点三：
此时join的作用就凸显出来了，join所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，一直等待其他的子线程执行结束之后，主线程在终止，例子见下面三。
知识点四：
join有一个timeout参数：
当设置守护线程时，含义是主线程对于子线程等待timeout的时间将会杀死该子线程，最后退出程序。所以说，如果有10个子线程，全部的等待时间就是每个timeout的累加和。简单的来说，就是给每个子线程一个timeout的时间，让他去执行，时间一到，不管任务有没有完成，直接杀死。
没有设置守护线程时，主线程将会等待timeout的累加和这样的一段时间，时间一到，主线程结束，但是并没有杀死子线程，子线程依然可以继续执行，直到子线程全部结束，程序退出。
一：Python多线程的默认情况
import threading
import time
def run():
time.sleep(2)
print('当前线程的名字是： ', threading.current_thread().name)
time.sleep(2)
if __name__ == '__main__':
start_time = time.time()
print('这是主线程：', threading.current_thread().name)
thread_list = []
for i in range(5):
t = threading.Thread(target=run)
thread_list.append(t)
for t in thread_list:
print('主线程结束！' , threading.current_thread().name)
print('一共用时：', time.time()-start_time)
其执行结果如下
我们的计时是对主线程计时，主线程结束，计时随之结束，打印出主线程的用时。
主线程的任务完成之后，主线程随之结束，子线程继续执行自己的任务，直到全部的子线程的任务全部结束，程序结束。
二：设置守护线程
import threading
import time
def run():
time.sleep(2)
print('当前线程的名字是： ', threading.current_thread().name)
time.sleep(2)
if __name__ == '__main__':
start_time = time.time()
print('这是主线程：', threading.current_thread().name)
thread_list = []
for i in range(5):
t = threading.Thread(target=run)
thread_list.append(t)
for t in thread_list:
t.setDaemon(True)
print('主线程结束了！' , threading.current_thread().name)
print('一共用时：', time.time()-start_time)
其执行结果如下，注意请确保setDaemon()在start()之前。
非常明显的看到，主线程结束以后，子线程还没有来得及执行，整个程序就退出了。
三：join的作用
import threading
import time
def run():
time.sleep(2)
print('当前线程的名字是： ', threading.current_thread().name)
time.sleep(2)
if __name__ == '__main__':
start_time = time.time()
print('这是主线程：', threading.current_thread().name)
thread_list = []
for i in range(5):
t = threading.Thread(target=run)
thread_list.append(t)
for t in thread_list:
t.setDaemon(True)
for t in thread_list:
print('主线程结束了！' , threading.current_thread().name)
print('一共用时：', time.time()-start_time)
其执行结果如下：
可以看到，主线程一直等待全部的子线程结束之后，主线程自身才结束，程序退出。
阅读(...) 评论()Python中threading的join和setDaemon的区别及用法［例子］ - 小西红柿 - 博客园
随笔 - 1, 文章 - 655, 评论 - 1, 引用 - 0
http://blog.csdn.net/zhangzheng0413/article/details/
Python多线程编程时，经常会用到join()和setDaemon()方法，今天特地研究了一下两者的区别。
1、join ()方法：主线程A中，创建了子线程B，并且在主线程A中调用了B.join()，那么，主线程A会在调用的地方等待，直到子线程B完成操作后，才可以接着往下执行，那么在调用这个线程时可以使用被调用线程的join方法。
原型：join([timeout])
& &&&里面的参数时可选的，代表线程运行的最大时间，即如果超过这个时间，不管这个此线程有没有执行完毕都会被回收，然后主线程或函数都会接着执行的。
import&threading&&
import&time&&
class&MyThread(threading.Thread):&&
&&&&&&&&def&__init__(self,id):&&
&&&&&&&&&&&&&&&&threading.Thread.__init__(self)&&
&&&&&&&&&&&&&&&&self.id&=&id&&
&&&&&&&&def&run(self):&&
&&&&&&&&&&&&&&&&x&=&0&&
&&&&&&&&&&&&&&&&time.sleep(10)&&
&&&&&&&&&&&&&&&&print&self.id&&
if&__name__&==&"__main__":&&
&&&&&&&&t1=MyThread(999)&&
&&&&&&&&t1.start()&&
&&&&&&&&for&i&in&range(5):&&
&&&&&&&&&&&&&&&&print&i&&
执行后的结果是：
机器上运行时，4和999之间，有明显的停顿。解释：线程t1 start后，主线程并没有等线程t1运行结束后再执行，而是先把5次循环打印执行完毕（打印到4），然后sleep（10）后，线程t1把传进去的999才打印出来。
现在，我们把join()方法加进去(其他代码不变)，看看有什么不一样，例子：
import&threading&&
import&time&&
class&MyThread(threading.Thread):&&
&&&&&&&&def&__init__(self,id):&&
&&&&&&&&&&&&&&&&threading.Thread.__init__(self)&&
&&&&&&&&&&&&&&&&self.id&=&id&&
&&&&&&&&def&run(self):&&
&&&&&&&&&&&&&&&&x&=&0&&
&&&&&&&&&&&&&&&&time.sleep(10)&&
&&&&&&&&&&&&&&&&print&self.id&&
if&__name__&==&"__main__":&&
&&&&&&&&t1=MyThread(999)&&
&&&&&&&&t1.start()&&
&&&&&&&&t1.join()&&
&&&&&&&&for&i&in&range(5):&&
&&&&&&&&&&&&&&&&print&i&&
执行后的结果是：&
机器上运行时，999之前，有明显的停顿。解释：线程t1 start后，主线程停在了join()方法处，等sleep（10）后，线程t1操作结束被join，接着，主线程继续循环打印。
2、setDaemon()方法。主线程A中，创建了子线程B，并且在主线程A中调用了B.setDaemon(),这个的意思是，把主线程A设置为守护线程，这时候，要是主线程A执行结束了，就不管子线程B是否完成,一并和主线程A退出.这就是setDaemon方法的含义，这基本和join是相反的。此外，还有个要特别注意的：必须在start() 方法调用之前设置，如果不设置为守护线程，程序会被无限挂起。
例子：就是设置子线程随主线程的结束而结束：
import&threading&&
import&time&&
class&MyThread(threading.Thread):&&
&&&&&&&&def&__init__(self,id):&&
&&&&&&&&&&&&&&&&threading.Thread.__init__(self)&&
&&&&&&&&def&run(self):&&
&&&&&&&&&&&&&&&&time.sleep(5)&&
&&&&&&&&&&&&&&&&print&"This&is&"&+&self.getName()&&
if&__name__&==&"__main__":&&
&&&&&&&&t1=MyThread(999)&&
&&&&&&&&t1.setDaemon(True)&&
&&&&&&&&t1.start()&&
&&&&&&&&print&"I&am&the&father&thread."&&
执行后的结果是：
I&am&the&father&thread.&&
可以看出，子线程t1中的内容并未打出。解释：t1.setDaemon(True)的操作，将父线程设置为了守护线程。根据setDaemon()方法的含义，父线程打印内容后便结束了，不管子线程是否执行完毕了。
程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程就分兵两路，分别运行，那么当主线程完成想退出时，会检验子线程是否完成。如果子线程未完成，则主线程会等待子线程完成后再退出。但是有时候我们需要的是，只要主线程完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以用setDaemon方法了。
所以，join和setDaemon的区别如上述的例子，它们基本是相反的。Python中threading的join和setDaemon的区别及用法［例子］ - CSDN博客
Python中threading的join和setDaemon的区别及用法［例子］
Python多线程编程时，经常会用到join()和setDaemon()方法，今天特地研究了一下两者的区别。
1、join ()方法：主线程A中，创建了子线程B，并且在主线程A中调用了B.join()，那么，主线程A会在调用的地方等待，直到子线程B完成操作后，才可以接着往下执行，那么在调用这个线程时可以使用被调用线程的join方法。
原型：join([timeout])
& &&&里面的参数时可选的，代表线程运行的最大时间，即如果超过这个时间，不管这个此线程有没有执行完毕都会被回收，然后主线程或函数都会接着执行的。
import threading
import time
class MyThread(threading.Thread):
def __init__(self,id):
threading.Thread.__init__(self)
self.id = id
def run(self):
time.sleep(10)
print self.id
if __name__ == &__main__&:
t1=MyThread(999)
t1.start()
for i in range(5):
执行后的结果是：
机器上运行时，4和999之间，有明显的停顿。解释：线程t1 start后，主线程并没有等线程t1运行结束后再执行，而是先把5次循环打印执行完毕（打印到4），然后sleep（10）后，线程t1把传进去的999才打印出来。
现在，我们把join()方法加进去(其他代码不变)，看看有什么不一样，例子：
import threading
import time
class MyThread(threading.Thread):
def __init__(self,id):
threading.Thread.__init__(self)
self.id = id
def run(self):
time.sleep(10)
print self.id
if __name__ == &__main__&:
t1=MyThread(999)
t1.start()
for i in range(5):
执行后的结果是：&
机器上运行时，999之前，有明显的停顿。解释：线程t1 start后，主线程停在了join()方法处，等sleep（10）后，线程t1操作结束被join，接着，主线程继续循环打印。
2、setDaemon()方法。主线程A中，创建了子线程B，并且在主线程A中调用了B.setDaemon(),这个的意思是，把主线程A设置为守护线程，这时候，要是主线程A执行结束了，就不管子线程B是否完成,一并和主线程A退出.这就是setDaemon方法的含义，这基本和join是相反的。此外，还有个要特别注意的：必须在start()
方法调用之前设置，如果不设置为守护线程，程序会被无限挂起。
例子：就是设置子线程随主线程的结束而结束：
import threading
import time
class MyThread(threading.Thread):
def __init__(self,id):
threading.Thread.__init__(self)
def run(self):
time.sleep(5)
print &This is & + self.getName()
if __name__ == &__main__&:
t1=MyThread(999)
t1.setDaemon(True)
t1.start()
print &I am the father thread.&
执行后的结果是：
I am the father thread.
可以看出，子线程t1中的内容并未打出。解释：t1.setDaemon(True)的操作，将父线程设置为了守护线程。根据setDaemon()方法的含义，父线程打印内容后便结束了，不管子线程是否执行完毕了。
程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程就分兵两路，分别运行，那么当主线程完成想退出时，会检验子线程是否完成。如果子线程未完成，则主线程会等待子线程完成后再退出。但是有时候我们需要的是，只要主线程完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以用setDaemon方法了。
所以，join和setDaemon的区别如上述的例子，它们基本是相反的。
本文已收录于以下专栏：
相关文章推荐
事情的起因是我在看下面一段代码遇到的疑惑，明明是while True,为什么代码没有死循环？？class D(threading.Thread):
def __init__(self, que...
在Python多线程编程的时候，经常需要用到join函数和setDaemon函数。之前对这两个函数一直理解不是很到位。今天查阅了很多资料，对两个函数的认识更加的深入一些了。
      join（[...
（2）setDaemon方法：
join(timeout=None) Wait until the thread terminates. This blocks the calling thread until the thread...
Join方法：如果一个线程在执行过程中要调用另外一个线程，并且等到其完成以后才能接着执行，
那么在调用这个线程时可以使用被调用线程的join方法。
代码如下：
import threadi...
这篇文章是用来说一下我写的一个 关于 ddpush 的Web管理的解决方案或者说是解决思路我在github上提交了我写的这个项目 (大家可以右击下面的文字 在新标签中打开 我不知道怎么在这个编辑器中直...
上一篇，我们学习了TCPClientBase这个类。这是个以TCP通信方式的一个客户端类。我们下面来学习另一种方式通信的UDP客户端类。这个UDP客户端类。和TCP客户端类基本上是相同的。在上一篇TC...
我们接着来学习ddpush的源代码。再ddpush的源代码中。提供了两个example 来为我们讲解如何具体的使用TCPClientBase和UDPClientBase这两个类。前面我们已经吧这两个类...
Java线程池
线程池编程
java.util.concurrent多线程框架---线程池编程（一）
一般的服务器都需要线程池，比如Web、FTP等服务器，不过它们一般都自己实现了线程池，比如以...
${COLUMN:-}
如果COLUMN是空变量，或者变量不存在，返回-ho
他的最新文章
讲师：宋宝华
讲师：何宇健
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)}