操作系统分时技术（对于进程而言）：

将处理机的运行时间分成很短的时间片，按时间片轮流把处理机分配给各联机作业使用。

特点：

多路性，交互性，独立性，及时性

目标：

对用户响应的及时性，即不至于用户等待每一个命令的处理时间过长

进程的定义:

执行中的程序称为进程；

程序和进程的区别：

程序是指令的集合，是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念。

进程的缺点：

进程只能在一个时间干一件事；
进程在执行过程中如果阻塞，例如等待输入，整个进程就会挂起，即使进程中有些工作不依赖输入的数据，也将无法执行
例子：若QQ是一个只能在同一时间干一件事的独立进程的话，则监听键盘输入，监听他人发送信息，显示他人发送的信息将无法同步实现

线程的定义（thread）：

线程是操作系统能够进行运算调度的最小单位。它被包含在进程中，是进程中的实际运作单位。一条进程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务

进程和线程的区别：

1.线程是共享进程的地址空间来创建的，进程有自己的地址空间。
2.线程可以直接接受它所属进程的数据段，而进程需要复制它父进程的数据段不能直接调用。
3.线程可以在所属进程中直接与其它线程进行通讯，进程必须使用进程间通信来与其它进程进行通讯。
4.新的线程很容易创建，新的进程需要复制其父进程。
5.对于相同进程而言，线程可以远超过其它线程对其进行控制；进程的控制力只有父进程大于子进程。
6.修改主线程（取消，修改优先级等）可能会影响进程中其它线程；修改父进程不能影响子进程。

线程的并发机制：

线程有开始，顺序执行和结束三个部分。还有一个指令指针用于记录运行的位置，
线程运行被抢占（中断），被暂时的挂起（睡眠），让其它线程运行（让步）。线程在进程中共享数据。

线程的并发本质：

单cpu中，并行的实现是通过规定线程运行时间片并进行让步来实现的。

线程并发的风险与解决：

竞态条件（race condition）的产生（数据访问的顺序不一样），导致数据结果的不一致。
使用线程库的同步语句来控制线程的执行和数据的访问。

python中多线程的实现：

方法1直接创建线程对象

import time
from datatime import datatime
import threading #python中提供线程相关操作的库
# 每个进程默认都有一个线程，这个线程叫主线程；其他的线程都叫子线程
def download(file_name): #模拟线程
    print("开始下载%s"%file_name,datatime.now()) # 打印当前时间，线程起始时间
    time.sleep(5) #线程挂起5秒
    print("%s下载完成"%file_name,datatime.now()) # 打印当前时间，线程终止时间

# 用模拟单线程进行对比
# 1.单线程下载两个电影：
# 在一个线程中下载两个电影：时间是两个电影下载的总和
download("复联4")
download("007")

# 2.线程模块
# 1）current_thread 函数 - 获取当前线程
print(threading.current_thread()) #当前打印的是主进程 

# 2）Thread类
'''
Thread类的对象就是线程。所以需要子线程就创建这个类的对象
Thread(target,args,kwargs)
target - 函数，需要在当前创建的子线程中去调用的函数
args/kwargs - 调用target中的函数需要的实参列表
'''
# a.创建线程对象
t1 = threading.Thread(target=download, args("复联4",)) #元组写法
# t1 = threading.Thread(target=download, kwargs = {"film_name":"复联4"})
t2 = threading.Thread(target=download, args("007",))

# b.开始执行子线程中的任务：线程对象.start()
'''
通过start方法，在子线程中去调用target对应的函数
'''
t1.start()
t2.start()

方法2.创建自己的线程类

from threading import *
import time
from datatime import datatime

# 1.创建自己的线程类
'''
1) 声明一个类继承Thread
2) 实现run方法，这个方法中的任务就是需要在子线程中执行的任务
   注意：一个进程中如果有多个线程，程序会在所有的线程都结束的时候才结束；发生异常崩溃其实崩溃的是线程
'''
class DownloadThread(Thread):
    def __init__(self, file_name):
        super().__init__()
        self.film_name = film_name
    
    def run(self):
    # print(current_thread())
    # print("在子线程中执行的代码")
    print("开始下载：%s"%self.film_name, datatime.now())
    # print([1, 2][3]) #检验线程崩溃后其他线程是否正常使用
    time.sleep(3)
    print("结束下载%s"%self.film_name, datatime.now())
# 3) 用子类直接创建线程对象
t1 = DownloadThread('复联4')
t2 = DownloadThread('长江7号')
# 4) 通过start去执行子线程中的任务
t1.start()
t2.start()
# 注意：t1.run()    # 不能直接调用run方法,因为这样调用不会在子线程中执行任务会在主线程中调用，详情看源码和结果
# t2.run()
'''
<_MainThread(MainThread, started 360)>
开始下载: 复联4 2019-05-10 11:50:05.386988
结束下载: 复联4 2019-05-10 11:50:08.387990
<_MainThread(MainThread, started 360)>
开始下载: 长江7号 2019-05-10 11:50:08.387990
结束下载: 长江7号 2019-05-10 11:50:11.388084
'''
while True:
    input('>>>:')# 主线程调用与子线程互不干扰

线程控制join方法

from threading import Thread
from datetime import datetime
import time
from random import randint

class DownloadThread(Thread):
    def __init__(self, name, time):
        super().__init__()
        self.name = name
        self.time = time
    
    def run(self):
        print("开始下载：%s"%self.name)
        time.sleep(self.time)
        print("下载结束：%s"%self.name)

t1 = DownloadThread("abc", 5)
t2 = DownloadThread("def", 7)

t2.start()
t1.start()

# 1.join
'''
如果希望某个任务是在某个线程结束后才执行，那就将这个任务的代码放在对应线程对象调用join方法的后面
'''
t1.join()
t2.join()
print("下载完成") #实现需求：两个完成时间不同的任务均完成后进行打印

'''
需求：一个任务完成后再执行另一个任务，join方法解决方案
'''
t1 = DownloadThread('沉默的羔羊', 4)
t2 = DownloadThread('恐怖游轮', 5)
t2.start()
t2.join()
t1.start()

竞态条件时数据操作的解决方案(锁)

问题

1.问题
当多个线程同时对一个数据进行读写操作，可能会出现一个线程刚把数据读出来还没来得及写进去，另外一个线程进行读操作的数据安全问题。
2.解决 - 加锁
1）保证每个数据对应一个锁对象
2）操作数据前加锁，数据操作完成后释放锁

import time
from threading import Thread, Lock

class Account:
    def __init__(self, name, tel, balance=50)
        self.name = name
        self.tel = tel
        self.balance = balance
        # 关联一个锁对象
        self.lock = Lock()
    def save_money(self, money):
        print("开始存钱")
        # 加锁
        self.lock.acquire()
        value = self.balance
        time.sleep(4)
        self.balance = value + money
        print("存钱成功：%.2f"%self.balance)
        # 释放锁
        self.lock.release()
    def draw_money(self, money):
        print("开始取钱")
        #加锁
        self.lock.acquire()
        value = self.balance
        if value<money:
            print("取钱失败！余额不足")
            return
        self.balance = value - money
        print("取钱成功：%.2f"%self.balance)
        # 释放锁
        self.lock.release()
        
account = Account("小H", "13893177183", 10000)

# 一个线程去存钱
t1 = Thread(target=account, save_money, args=(1000,))
# 一个线程去取钱
t2 = Thread(target=account, draw_money, args=(500,))

t1.start()
t2.start()


print("======分隔符======")
# 添加数据
share_data = 10000
lock = Lock()

def add_data(value):
    lock.acquire()
    global share_data #保证函数内赋值share_data时，赋值的是全局变量
    old_data = share_data
    time.sleep(4)
    share_data = old_data + value  #保证函数内赋值share_data时，赋值的是全局变量如果上方未声明全局变量，则函数内会创建同名局部变量从而报错
    lock.release()

t1 = Thread(target=add_data, args=(200,))
t2 = Thread(target=add_data, args=(300,))
t1.start()
t2.start()

t1.join()
t2.join()

print(share_data)