进程与线程

进程和线程是操作系统的基本概念，计算机是由硬件和软件组成。硬件中的CPU是计算机的核心，他承担计算机的所有任务。
操作系统是运行在硬件上的软件，是计算机的管理者，他负责资源的管理和分配、任务的调度。
程序是运行在系统上的具有某种功能的软件，比如浏览器、音乐、软件等。
每次执行程序的时候，都会完成一定的功能，比如说浏览器帮我们打开网页，为了保证其独立性，就需要一个专门的管理和控制执行程序
的数据结构--进程控制块。
进程就是一个程序在一个数据集上的一次动态执行过程。进程一般由程序、数据集、进程控制块三部分组成。
我们编写的程序用来描述进程要完成哪些功能以及如何完成；数据集则是程序在执行过程中所需要使用的资源；进程控制块用来记录进程的
外部特征，描述进程的执行变化过程，系统可以利用他来控制和管理进程，他是系统感知进程存在的唯一标志。
线程是操作系统能够进行运算调度的最小单位。他被包含在进程之中，是进程中的实际运作单位。
一个线程指的是进程中一个单一顺序的控制流。
一个进程中可以并发多个线程，每条线程并行执行不同的任务。

1.进程是不活泼的，进程从来不执行任何东西，他只是线程的容器，若要是进程完成某种操作，他必须有一个在他环境中运行的线程，此线程负责
执行包含在进程地址空间中的代码。
2.创建一个进程时，操作系统会自动创建这个进程的第一个线程，称为主线程。此后该线程可以创建其他的线程。
3.线程与进程的关系：线程是属于进程的，线程运行在进程空间内，同一进程所产生的线程共享同一内存空间，当进程退出时，该进程产生的
线程都会被强制清楚并退出。线程可与同一进程的其他线程共享进程所拥有的全部资源，但是其本身基本上不拥有系统资源，只拥有一点在运行中必不可少的信息（如程序计数器、一组寄存器和栈）。

线程与进程的区别：
进程：对各种资源管理的集合;   
线程：操作系统最小的调度单位，是一串指令的集合。

进程中第一个线程是主线程，主线程创建其他线程，其他线程也可以创建线程，线程之间是平等的
进程有父进程、子进程，独立的内存空间，唯一的进程标识符pid

启动线程比启动进程快。运行进程和运行线程速度上是一样的，没有可比性。
线程共享内存空间，进程的内存是独立的

父进程生成子进程，相当于克隆一份内存空间。进程之间不能直接访问
创建新线程很简单，创建新进程需要对其父进程进行一次克隆
一个线程可以控制和操作同一进程里的其他线程，但是进程只能操作子进程

同一个进程之间的线程之间可以直接通信
两个进程想通信必须通过一个中间代理来实现

进程的特性：
动态性:进程的实质是程序的一次执行过程,进程是动态产生、动态消亡的
并发性:任何进程都可以同其他进程一起并发执行
独立性:进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位
异步性：每个进程都以相互独立、不可预知的速度向前推进

进程由程序、数据和进程控制块三部分组成

多任务的实现有3种方式：
多进程模式
多线程模式
多进程+多线程模式


# 直接调用
import threading
import time
def run(n):
    # time.sleep(2)
    print('task', n)
t1=threading.Thread(target=run,args=('t1',))
t2=threading.Thread(target=run,args=('t2',))
t1.start()
t2.start()

# task t1
# task t2


继承式调用
import threading
class MyThread(threading.Thread):
    def __init__(self,n):
        super(MyThread,self).__init__()
        self.n=n
    def run(self):
        print('这种方式函数名必须是run，写死的',self.n)
t1=MyThread('t1')
t2=MyThread('t2')
t1.start()
t2.start()

# 这种方式函数名必须是run，写死的 t1
# 这种方式函数名必须是run，写死的 t2



使用传统编程看执行任务花费的时间
import time
import threading

def task1():
    time.sleep(5)
    print('任务一完成',time.ctime())
def task2():
    time.sleep(5)
    print('任务二完成',time.ctime())
print('执行任务前打印当前时间',time.ctime())
task1()
task2()
print('执行结束，记录结束时间',time.ctime())

# 执行任务前打印当前时间 Sun Mar 10 08:21:49 2019
# 任务一完成 Sun Mar 10 08:21:54 2019
# 任务二完成 Sun Mar 10 08:21:59 2019
# 执行结束，记录结束时间 Sun Mar 10 08:21:59 2019



采用多线程实行并行处理，查看执行同样任务所花费的时间
import time
import threading

def task1():
    time.sleep(3)
    print('任务一完成',time.ctime())
def task2():
    time.sleep(3)
    print('任务二完成',time.ctime())
print('执行任务前打印当前时间',time.ctime())
t1=threading.Thread(target=task1)
t2=threading.Thread(target=task2)
t1.start()
t2.start()
t1.join()
t2.join()
print('执行结束，打印当前时间')

# 执行任务前打印当前时间 Sun Mar 10 08:28:44 2019
# 任务二完成 任务一完成 Sun Mar 10 08:28:47 2019
# Sun Mar 10 08:28:47 2019
# 执行结束，打印当前时间



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

def loop():
    print('线程%s正在执行。。。'%threading.current_thread().name)
    n=0
    while n<5:
        n+=1
        print('线程%s>>>%s'%(threading.current_thread().name,n))
        time.sleep(2)
    print('线程%s结束'%threading.current_thread().name)
print('主线程%s正在执行。。。'%threading.current_thread().name)
# 给线程起名hello
t=threading.Thread(target=loop,name='hello')
t.start()
t.join()
print('主线程%s结束'%threading.current_thread().name)

# 主线程MainThread正在执行。。。
# 线程hello正在执行。。。
# 线程hello>>>1
# 线程hello>>>2
# 线程hello>>>3
# 线程hello>>>4
# 线程hello>>>5
# 线程hello结束
# 主线程MainThread结束



当我们使用setDaemon(True)方法时，设置子线程为守护线程时，主线程一旦执行结束，则全部线程全部被终止执行，
可能出现的情况就是，子线程的任务还没有完全结束，就被迫停止。不设置的话默认为setDaemon(False),
如果你设置一个线程为守护线程，就表示这个线程是不重要的，在进程退出的时候，不用等待这个线程退出。
import time
import threading

def task():
    print('start fun',time.ctime())
    time.sleep(2)
    print('end fun',time.ctime())
t1=threading.Thread(target=task)
print('线程名字',t1.getName(),time.ctime()) #显示实例线程名字
t1.setDaemon(True)  # 设置t1为守护线程
t1.start()
time.sleep(1)
print(threading.current_thread().name,time.ctime()) # 主线程执行结束，则全部终止

# 线程名字 Thread-1 Sun Mar 10 16:58:14 2019
# start fun Sun Mar 10 16:58:14 2019
# MainThread Sun Mar 10 16:58:15 2019




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



# 没有锁
import threading

balance=0
def task(n):
    global balance
    balance+=n
    balance-=n
def task2(arg,n):
    while arg>0:
        # lock.acquire()#获得锁
        task(n)
        arg-=1

t1=threading.Thread(target=task2,args=(880000,5))
t2=threading.Thread(target=task2,args=(970000,6))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)



import threading

balance=0
lock=threading.RLock()
def task(n):
    global balance
    balance+=n
    balance-=n
def task2(arg,n):
    while arg>0:
        lock.acquire()#获得锁
        try:
            task(n)
        finally:
            lock.release()
        arg-=1

t1=threading.Thread(target=task2,args=(1880000,5))
t2=threading.Thread(target=task2,args=(1770000,6))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)

当多个线程同时执行lock.acquire()时，只有一个线程能够成功地获取锁，然后执行代码，其他线程就继续等待直到获得锁为止。
获得锁的线程用完后一定要释放锁，否则那些苦苦等待的线程将永远等待下去，称为死线程。
锁的好处就是确保了某段代码只能由一个线程从头到尾的执行。坏处当然也很多，首先是阻止了多线程并发执行，包含锁的某段代码实际上
只能以单线程的模式执行，效率就大大下降了。其次，由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会
造成死锁，导致多个线程全部挂起，既不能执行，也无法结束，只能靠操作系统强制终止。

在python中，不能利用多线程实现多核任务，但可以通过多进程实现多核任务。

import time
import threading

globals_num=0
#lock=threading.RLock()
def Func():
    # lock.acquire()
    global globals_num
    globals_num+=1
    time.sleep(1)
    print(globals_num)
    # lock.release()
for i in range(10):
    t=threading.Thread(target=Func)
    t.start()

# 1010
#
# 10
# 101010
#
# 10
#
# 101010



import time
import threading

globals_num=0
lock=threading.RLock()
def Func():
    lock.acquire()
    global globals_num
    globals_num+=1
    time.sleep(1)
    print(globals_num)
    lock.release()
for i in range(10):
    t=threading.Thread(target=Func)
    t.start()

# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# 10

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

ThreadLocal，很多地方叫做线程本地变量，也有些地方叫做线程本地存储，其实意思差不多。ThreadLocal为变量在每个线程中都创建了
一个副本，那么每个线程可以访问自己内部的副本变量。
ThreadLocal最常用的地方就是为每个线程绑定一个数据库连接，HTTP请求，用户身份信息等，这样一个线程的所有调用到的处理函数都可以
非常方便地访问这些资源。

在新的线程中local_data并没有x属性，并且在新线程中的赋值并不会影响到其他线程。
去掉local_data=Widgt()的注释，local_data就变成了线程共享的变量。

import threading

class Widgt(object):
    pass

def test():
    local_data=threading.local()
    # local_data=Widgt()
    local_data.x=1
    def thread_func():
        print('Has x in new thread:%s'%hasattr(local_data,'x'))#hasattr(实例名，属性名)判断对象中是否存在该属性
        local_data.x=2
        print('Has x in new thread:%s'%hasattr(local_data,'x'))
        print('x in pre thread is %s'%local_data.x)
    t=threading.Thread(target=thread_func)
    t.start()
    t.join()
    print('x in pre thread is %s'%local_data.x)
if __name__=='__main__':
    test()

# Has x in new thread:False
# Has x in new thread:True
# x in pre thread is 2
# x in pre thread is 1




创建全局ThreadLocal对象
import threading

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)



multiprocessing模块提供了一个Process类来代表一个进程对象，multiprocessing模块就是跨平台版本的多进程模块。
import time
import multiprocessing

def add(number,value,lock):
    lock.acquire()
    try:
        print('init add{0} number={1}'.format(value,number))
        for i in range(1,6):
            number+=value
            time.sleep(1)
            print('add{0} number={1}'.format(value,number))
    except Exception as e:
        raise e
    finally:
        lock.release()
if __name__=='__main__':
    lock=multiprocessing.Lock()
    number=0
    p1=multiprocessing.Process(target=add,args=(number,1,lock))
    p2=multiprocessing.Process(target=add,args=(number,3,lock))
    p1.start()
    p2.start()
    print('main end')

# main end
# init add1 number=0
# add1 number=1
# add1 number=2
# add1 number=3
# add1 number=4
# add1 number=5
# init add3 number=0
# add3 number=3
# add3 number=6
# add3 number=9
# add3 number=12
# add3 number=15




下面的例子演示了启动一个子进程并等待其结束

from multiprocessing import Process
import os

#子进程要执行的代码
def run_proc(name):
    print('Run child process %s(%s)...'%(name,os.getpid()))
if __name__=='__main__':
    print('Parent process %s.'%(os.getpid()))
    p=Process(target=run_proc,args=('test',))
    print('Child process will start.')
    p.start()  #启动进程
    p.join() #等待子进程执行结束后再往下执行，通常用于进程间的同步
    print('Child process end.')

# Parent process 6012.
# Child process will start.
# Run child process test(8724)...
# Child process end.





Pool类 在使用Python进行系统管理时，特别是同时操作多个文件目录或者远程控制多台主机，并行操作可以节约大量的时间。如果操作
对象数目不大时，还可以直接使用Process类动态的生成多个进程，十几个还好，但是如果上百个甚至更多，那手动去限制进程数量就显得
特别的繁琐，此时进程池就派上用场了。
Pool类可以提供指定数量的进程共用户调用，当有新的需求提交到Pool中时，如果池还没满，就会创建一个新的进程来执行请求。如果
池满，请求就会告知等待，直到池中有进程结束，才会创建新的进程来执行这些请求。
下面介绍multiprocessing模块下的Pool类下的几个方法
apply()
apply(func[,args=()[,kwds={}]])该函数用于传递不定参数，主进程会被阻塞直到函数执行结束(不建议使用，并且3.x以后不再出现)
apply_async()
apply_async(func[,args=()[,kwds={}[,callback=None]]])与apply用法一样，但他是非阻塞且支持结果返回进行回调
map()
map(func,iterable[,chunksize=None]) Pool类中的map方法，与内置的map函数用法基本一致，它会使进程阻塞直到返回结果。注意：第二个
参数虽然是迭代器，但在实际使用中，必须在整个队列都就绪后，程序才会运行子进程。
close()关闭进程池，使其不再接收新的任务。
terminate()结束工作进程，不再处理未完成的任务。
join()主进程阻塞等待子进程的退出，join方法必须在close或terminate之后使用。

from multiprocessing import Pool
import os
import time
import random

def long_time_task(name):
    print('运行任务%s(%s)...'%(name,os.getpid()),time.ctime()) # os.getpid()获得当前进程的进程号
    start=time.time()
    time.sleep(random.random()*3)
    end=time.time()
    print('任务%s运行%0.2f秒'%(name,(end-start)),time.ctime())
if __name__=='__main__':
    print('Parent process %s.'%os.getpid(),time.ctime())
    p=Pool(4) # 创建拥有4个进程数量的进程池
    for i in range(5):
        p.apply_async(long_time_task,args=(i,))
    print('Waiting for all subprocesses done...',time.ctime())
    p.close()
    p.join()
    print('All subprocesses done.',time.ctime())

# Parent process 9704. Mon Mar 11 16:14:31 2019
# Waiting for all subprocesses done... Mon Mar 11 16:14:31 2019
# 运行任务0(5832)... Mon Mar 11 16:14:31 2019
# 运行任务1(7004)... Mon Mar 11 16:14:31 2019
# 运行任务2(6956)... Mon Mar 11 16:14:31 2019
# 运行任务3(1632)... Mon Mar 11 16:14:31 2019
# 任务3运行1.00秒 Mon Mar 11 16:14:32 2019
# 运行任务4(1632)... Mon Mar 11 16:14:32 2019
# 任务1运行1.98秒 Mon Mar 11 16:14:33 2019
# 任务2运行2.36秒 Mon Mar 11 16:14:34 2019
# 任务0运行2.98秒 Mon Mar 11 16:14:34 2019
# 任务4运行2.01秒 Mon Mar 11 16:14:34 2019
# All subprocesses done. Mon Mar 11 16:14:35 2019




Process之间肯定是需要通信的，操作系统提供了很多机制来实现进程间的通信。Python的multiprocessing模块包装了底层的机制，
提供了Queue,Pipes等多种方式来交换数据。我们以Queue为例，在父进程中创建两个子进程，一个往Queue里写数据，另一个从Queue里
读取数据。

from multiprocessing import Process,Queue
import os
import time
import random

# 写数据进程执行的代码
def write(q):
    print('Process to write:%s'%os.getpid())
    for value in ['A','B','C']:
        print('Put %s to queue...'%value)
        q.put(value)
        time.sleep(random.random())
# 读数据进程执行的代码
def read(q):
    print('Process to read:%s'%os.getpid())
    while True:
        value=q.get(True)
        print('Get %s from queue.'%value)
if __name__=='__main__':
    q=Queue() # 父进程创建Queue，并创建给子进程
    w=Process(target=write,args=(q,))
    r=Process(target=read,args=(q,))
    w.start() # 启动子进程pw，写入
    r.start() # 启动子进程pr,读取
    w.join()
    r.terminate() # r

# Process to write:9048
# Put A to queue...
# Process to read:1580
# Get A from queue.
# Put B to queue...
# Get B from queue.
# Put C to queue...
# Get C from queue.




Queue是python标准库中的线程安全的队列（FIFO）实现，提供了一个适用于多线程编程的先进先出的数据结构，即队列，用来在生产者
和消费者线程之间的信息传递。基本FIFO队列 class queue.Queue(maxsize=0)
FIFO即First in First out ，先进先出。Queue提供了一个基本的FIFO容器，使用方法很简单，maxsize是一个整数，指明了队列中能存放的
数据个数的上限。一旦达到了上限，插入会导致阻塞，直到队列中数据被消费掉。如果maxsize小于或者等于0，队列大小没有限制。

import queue

q=queue.Queue()
for i in range(5):
    q.put(i)
while not q.empty():
    print(q.get())

# 0
# 1
# 2
# 3
# 4



LIFO队列 即 last in first out ，后进先出
class queue.LifoQueue(maxsize=0)

import queue

q=queue.LifoQueue(maxsize=0)
for i in range(5):
    q.put(i)
while not q.empty():
    print(q.get())

# 4
# 3
# 2
# 1
# 0