线程：线程是进程的执行单元，是进程内科调度的实体，是任务调度和执行的基本单元。一个进程包含一个或多个线程。

实现

因为线程是操作系统直接支持的执行单元，因此，高级语言通常都内置多线程的支持。
Python的线程是真正的PosixThread，而不是模拟出来的线程。
Python标准库提供两个模块：_thread 和 threading。_thread是低级模块，threading是高级模块。threading对_thread进行了封装。所以绝大多数情况下，我们只需要使用threading模块。例子如下：

把一个函数传入threading的Thread方法的target属性中，生成一个threading.Thread实例，然后用start()方法执行：

  1. import time, threading
  3. # 新线程执行的代码:
  4. def loop():
  5.     print('thread %s is running...' % threading.current_thread().name)
  6.     n = 0
  7.     while n < 5:
  8.         n = n + 1
  9.         print('thread %s >>> %s' % (threading.current_thread().name, n))
  10.         time.sleep(1)
  11.     print('thread %s ended.' % threading.current_thread().name)
  13. print('thread %s is running...' % threading.current_thread().name)
  14. t = threading.Thread(target=loop, name='LoopThread')
  15. t.start()
  16. t.join()
  17. print('thread %s ended.' % threading.current_thread().name) #主进程结束

运行结果：

  1. thread MainThread is running...
  2. thread LoopThread is running...
  3. thread LoopThread >>> 1
  4. thread LoopThread >>> 2
  5. thread LoopThread >>> 3
  6. thread LoopThread >>> 4
  7. thread LoopThread >>> 5
  8. thread LoopThread ended.
  9. thread MainThread ended.

由于任何进程默认就会启动一个线程，我们把该线程称为主线程，主线程又可以启动新的线程，Python的threading模块有个 current_thread() 函数，它永远返回当前线程的实例。主线程实例的名字叫MainThread，子线程的名字在创建时指定，我们用LoopThread命名子线程。名字仅仅在打印时用来显示，完全没有其他意义，如果不起名字Python就自动给线程命名为Thread-1，Thread-2……

守护线程

join( )函数：join所完成的工作就是线程同步，即主线程任务结束之前，进入阻塞状态，一直等待其他的子线程执行结束之后，主线程再终止。

  1. import threading
  2. import time
  5. def target():
  6.     print('{0} 当前的线程{1} 在运行' .format(time.strftime("%H:%M:%S",time.localtime(time.time())),threading.current_thread().name))
  8.     time.sleep(5)
  9.     print('{0} 当前的线程{1} 结束'.format(time.strftime("%H:%M:%S", time.localtime(time.time())),
  10.                                     threading.current_thread().name))
  12. print('{0} 当前的主线程{1} 在运行'.format(time.strftime("%H:%M:%S", time.localtime(time.time())),
  13.                                     threading.current_thread().name))
  14. t = threading.Thread(target=target, args=[])
  16. t.start()
  17. t.join()  # 阻塞进程
  18. print('{0} 当前的主线程{1} 结束'.format(time.strftime("%H:%M:%S", time.localtime(time.time())),
  19.                                     threading.current_thread().name))

添加join（）阻塞进程后,输出运行结果：

  1. 13:40:44 当前的主线程MainThread 在运行
  2. 13:40:44 当前的线程Thread-1 在运行
  3. 13:40:49 当前的线程Thread-1 结束
  4. 13:40:49 当前的主线程MainThread 结束

setDaemon()方法

主线程A中，创建了子线程B，并且在主线程A中调用了B.setDaemon(),这个的意思是:把主线程A设置为守护线程，这时候，要是主线程A执行结束了，就不管子线程B是否完成,一并和主线程A退出.这就是setDaemon方法的含义，这基本和join是相反的。此外，还有个要特别注意的：必须在start() 方法调用之前设置，如果不设置为守护线程，程序会被无限挂起。

  1. import threading
  2. import time
  5. class MyThread(threading.Thread):
  6.     def __init__(self, id):
  7.         threading.Thread.__init__(self)
  9.     def run(self):
  10.         time.sleep(5)
  11.         print("当前线程： " + self.getName())
  14. if __name__ == "__main__":
  15.     t1 = MyThread(999)
  16.     t1.setDaemon(True)
  17.     t1.start()
  18.     print("主线程结束")

运行结果：

主线程结束

可以看出，子线程t1中的内容并未打出。

解释：t1.setDaemon(True)的操作，将父线程设置为了守护线程。根据setDaemon()方法的含义，父线程打印内容后便结束了，不管子线程是否执行完毕了。

程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程就分兵两路，分别运行，那么当主线程完成想退出时，会检验子线程是否完成。如果子线程未完成，则主线程会等待子线程完成后再退出。

但是有时候我们需要的是，只要主线程完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以用setDaemon方法了。

LOCK

多线程和多进程最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响，而多线程中，所有变量都由所有线程共享，所以，任何一个变量都可以被任何一个线程修改，因此，线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了。

所以为了保证数据的正确，我们就要给线程需要的参数加锁，只有当锁释放后，并获得该锁，其他线程才能对参数进行修改。由于锁只有一个，无论多少线程，同一时刻最多只有一个线程持有该锁，所以，不会造成修改的冲突。

创建一个锁就是通过 threading.Lock() 来实现：

import time,threading
balance = 0
lock = threading.Lock()

def change_it(n):
    # 先存后取，结果应该为0:
    global balance
    balance = balance + n
    balance = balance - n

def run_thread(n):
    for i in range(100000):
        # 先要获取锁:
        lock.acquire()
        try:
            # 放心地改吧:
            change_it(n)
        finally:
            # 改完了一定要释放锁:
            lock.release()

t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)

执行结果:

0

当多个线程同时执行lock.acquire()时，只有一个线程能成功地获取锁，然后继续执行代码，其他线程就继续等待直到获得锁为止。

获得锁的线程用完后一定要释放锁，否则那些苦苦等待锁的线程将永远等待下去，成为死线程。所以我们用try…finally来确保锁一定会被释放。

锁的好处就是确保了某段关键代码只能由一个线程从头到尾完整地执行，坏处当然也很多，首先是阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了。其次，由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁，导致多个线程全部挂起，既不能执行，也无法结束，只能靠操作系统强制终止。

全局对象

在多线程环境下，每个线程都有自己的数据。一个线程使用自己的局部变量比使用全局变量好，因为局部变量只有线程自己能看见，不会影响其他线程，而全局变量的修改必须加锁。

但是局部变量也有问题，就是在函数调用的时候，传递起来很麻烦。

为了解决这个问题，ThreadLoacl应运而生：

import threading

# 创建全局ThreadLocal对象:
local_school = threading.local()


def process_student():
    # 获取当前线程关联的student:
    std = local_school.student
    print('Hello, %s (in %s)' % (std, threading.current_thread().name))


def process_thread(name):
    # 绑定ThreadLocal的student:
    local_school.student = name
    process_student()


t1 = threading.Thread(target=process_thread, args=('Alice',), name='Thread-A')
t2 = threading.Thread(target=process_thread, args=('Bob',), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()

执行结果：

Hello, Alice (in Thread-A)
Hello, Bob (in Thread-B)

全局变量local_school就是一个ThreadLocal对象，每个Thread对它都可以读写student属性，但互不影响。

你可以把local_school看成全局变量，但每个属性如local_school.student都是线程的局部变量，可以任意读写而互不干扰，也不用管理锁的问题，ThreadLocal内部会处理。

可以理解为全局变量local_school是一个dict，不但可以用local_school.student，还可以绑定其他变量，如local_school.teacher等等。

ThreadLocal最常用的地方就是为每个线程绑定一个数据库连接，HTTP请求，用户身份信息等，这样一个线程的所有调用到的处理函数都可以非常方便地访问这些资源。