进程：正在运行的一个程序，每个进程相互独立，并且运行在其专用且受保护的内存空间里面的。
线程：一个进程要想执行任务，必须得有线程（每个进程至少有一个线程），一个进程所有任务都在线程中执行。
主线程：每个进程默认有一个线程，这个线程叫主线程。默认情况下，所有的代码都是在主线程中执行的。
子线程：一个进程可以有多个线程。除了主线程以外，其他线程需要手动添加。
多线程原理：
同一时间，CPU只能处理一条线程，只有1条线程在工作。多线程并发执行，其实就是CPU快速的在多线程之间调度（切换），当CPU调度线程的时间足够快，就造成了多线程并发执行的假象。
使用情况：
让多个任务同时执行。
补充：
a、打印当前时间
import datetime
datetime.datetime.now()
b、延时
import time
time.sleep(s)
方式一
1、模块
python中内置模块 threading，用来支持多线程。Thread类的对象就是线程对象，需要线程的时候，就创建这个类或者这个类的子类对象。
import threading
获取当前线程对象 >>> 用于测试
threading.current_thread()
2、创建子线程对象
t1 = threading.Thread(target=download, args=('终结者',))
"""
target:需要在子线程中调用的函数的函数名，子线程中执行的任务就是函数里面的代码。
args:函数对应的参数值（元组）
返回值：创建好的线程对象
"""
3、执行
t1.start()
效果：
import threading
import datetime
import time
#模拟下载两个电影
def download(file):
print('开始下载：', datetime.datetime.now())
# 线程阻塞2s
time.sleep(2)
print(file+'下载结束',datetime.datetime.now())
print(threading.current_thread())
t1 = threading.Thread(target=download, args=('终结者2',))
t1.start()
t2 = threading.Thread(target=download, args=('沉默的羔羊',))
t2.start()
download('终结者1')
开始下载： 2018-09-13 11:08:56.927703
开始下载： 2018-09-13 11:08:56.928703
开始下载： 2018-09-13 11:08:56.928703
终结者2下载结束 2018-09-13 11:08:58.927818
<Thread(Thread-1, started 2324)>
沉默的羔羊下载结束 2018-09-13 11:08:58.928818
<Thread(Thread-2, started 5908)>
终结者1下载结束 2018-09-13 11:08:58.928818
<_MainThread(MainThread, started 5852)>
方式二---面向对象的多线程技术（重点）
1、声明一个类继承自Thread类
2、重写run方法，将需要在子线程中执行的任务放到run方法中
3、在需要子线程的位置去创建这个类的对象，然后调用start 方法去执行run中的任务。
from threading import Thread
import datetime
import time
class DownLoadThread(Thread):
def __init__(self, file):
super().__init__()
self.file = file
def run(self):
print('开始下载:<%s> 时间：%s'%(self.file,datetime.datetime.now()))
time.sleep(5)
print('下载结束:<%s>！ 时间：%s'%(self.file,datetime.datetime.now()))
print('===========')
t1 = DownLoadThread('沉默的羔羊')
t1.start()
print('+++++++++++')
结果：
===========
开始下载:<沉默的羔羊> 时间：2018-09-13 11:26:42.730664
+++++++++++
下载结束:<沉默的羔羊>！ 时间：2018-09-13 11:26:47.730950
三、join方法的使用
如果希望某个线程结束后才执行某个操作，就用线程对象调用 join（）
start（）会自动调用run（）
from threading import Thread
import time
import datetime
import random
class DownLoadThread(Thread):
def __init__(self, file):
super().__init__()
self.file = file
def run(self):
print(self.file+' 开始下载', datetime.datetime.now())
time.sleep(random.randint(5,15))
print(self.file+' 下载结束', datetime.datetime.now())
t1 = DownLoadThread('美丽人生')
t2 = DownLoadThread('怦然心动')
start = time.time()
t1.start()
t2.start()
#t1,t2都结束才执行
t1.join() #后面的代码在t1对应的线程结束后才执行
t2.join() #后面的代码在t1对应的线程结束后才执行
end = time.time()
print(end - start)
结果：
美丽人生 开始下载 2018-09-13 13:36:42.334387
怦然心动 开始下载 2018-09-13 13:36:42.334387
美丽人生 下载结束 2018-09-13 13:36:49.334787
怦然心动 下载结束 2018-09-13 13:36:50.336844
8.00445818901062
四、多线程的数据混乱问题
尽量避免多个线程对同一个数据进行操作
解决方法：对相关代码加锁，让同一时间只有能有一个线程进行操作，释放后，才能让其它线程操作
锁： 同步锁（RLock） 和 互斥锁（Lock）-- 了解
from threading import Lock
1、创建锁对象
self.lock = Lock()
# 一般写在__init__方法中
2、加锁
self.lock.acquire()
# 线程操作前
3、解锁
self.lock.release()
# 线程操作后
实例：
"""__author__=Deathfeeling"""
import time
from threading import Thread, Lock
class Account():
"""账号类"""
def __init__(self, balance):
self.balance = balance
# 创建锁对象
self.lock = Lock()
def save_money(self, amount):
"""存钱"""
print('开始存钱')
# 加锁
self.lock.acquire()
old_amount = self.balance
time.sleep(2)
self.balance = old_amount + amount
print('存钱成功！最新余额是：',self.balance)
# 解锁
self.lock.release()
def get_money(self, amount):
"""取钱"""
self.lock.acquire()
print('开始取钱')
old_amount = self.balance
if old_amount < amount:
print('余额不足')
return
time.sleep(2)
self.balance = old_amount - amount
print('取钱成功！最新余额是：', self.balance)
self.lock.release()
def show_balance(self):
print('当前余额：', self.balance)
account = Account(1000)
# account.save_money(200)
# account.get_money(100)
# account.show_balance()
t1 = Thread(target=account.save_money, args=(200,))
t2 = Thread(target=account.save_money, args=(300,))
t1.start()
t2.start()
结果：
开始存钱
开始存钱
存钱成功！最新余额是： 1200
存钱成功！最新余额是： 1500
