python入门之进程与线程

什么是进程、线程

　　进程：一个整体的形式暴露给操作系统管理，里面包含对各种资源的调用，内存的管理，网络接口的调用等，对各种资源管理的基本单位。

　　线程：操作系统最小的调度单位， 是一串指令的集合，进程中的一个执行单元。

　　一个进程至少有一个线程。

　　全局解释器锁（GIL）：python虚拟机的访问由全局解释器锁控制，这个锁能保证同一时刻只有一个线程运行。

进程与线程的区别

　　◐ 线程之间共享内存空间，而进程的内存是独立，即使是父子进程

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

　　◐ 创建新线程很简单，但是创建一个新进程需要克隆一次父进程

　　◐ 一个线程可以控制和操作同一个进程内的其他线程，而进程只能操作子进程

 

多线程环境中，python虚拟机的执行方式

　　（1）设置GIL

　　（2）切换到一个线程运行

　　（3）运行指定数量的指令或者线程主动让开控制

　　（4）把线程设置为睡眠状态

　　（5）解锁GIL

　　（6）从头再来执行其他的线程

 

Part1 简单的线程

import threading
import time

def test(n):
    print("thread",n)
    time.sleep(3)

t1 = threading.Thread(target=test,args=("tt1",))  # 启动一个线程t1，执行test函数，参数为字符串tt1
t2 = threading.Thread(target=test,args=("tt2",))
t1.start()  # 使用两个线程执行这个函数，cpu在t1执行完print后，遇到sleep，就会切换到t2执行print
t2.start()

# test("tt1")  # 而直接调用两个函数执行，cpu会先执行完第一个，再执行下一个，这样比多线程多了个执行sleep的时间
# test("tt2")

Part2 用类的形式启动线程

# 用类的形式启动线程
import threading

class MyThread(threading.Thread):
    def __init__(self,n):
        super(MyThread,self).__init__()
        self.n = n

    def run(self):  # 这里必须是run函数，不能取其他名，里面写死了会调用run函数
        print("run thread",self.n)

t1 = MyThread("tt1")
t2 = MyThread("tt2")
t1.start()
t2.start()

Part3 主线程等待子线程执行完成

import threading
import time

def run(n):
    print("th:",n,threading.current_thread())  # 可以查看当前进程是为主线程还是子线程
    time.sleep(2)

start_time = time.time()
t_list = []  # 定义一个空列表，用来存启动的子线程
for i in range(50):
    t = threading.Thread(target=run,args=("t-%d" %i,))
    t.start()
    t_list.append(t)
# print("cost time:",time.time()-start_time)
# 按目前所知可得，这里打印的时间是整个程序执行一共花的时间。但是最终执行下来时间只有0.02左右，里面怎么没有包含函数sleep的时间呢
# 一个进程至少有一个线程，从执行这个程序开始，就启动了一个主线程，而主线程中启动了50个子线程，而子线程启动后和主线程独立没有影响（主子并行）
# 其中的print语句也是主线程部分，sleep语句是子线程部分，所以打印的时间是主线程启动了50个子线程的时间，主线程并不会等待子线程执行完了再执行后面的程序
print(threading.active_count())  # 输出51，表示当前存活的线程，包含主线程
for t in t_list:
    t.join()

print("cost time:",time.time()-start_time,threading.current_thread())
# 这里就使用join来等待子线程的完成，其中等待是指主线程等待子线程执行完后再继续执行，默认程序最后都有一个join
# 不能直接在启动线程的循环里写join，那样会变成串行，因为每启动一个线程，都要等待执行完成后才启动下一个线程
# 这里直接循环每个已经启动了的线程，主线程会等所有的子线程执行完后再执行print时间

Part4 守护线程

# 守护线程，主线程执行完了，不管守护线程有没有执行完都退出
import threading
import time

def run(n):
    print("th:",n)
    time.sleep(2)

start_time = time.time()
for i in range(50):
    t = threading.Thread(target=run,args=("t%d" %i,))
    t.setDaemon(True)  # 把当前线程设置为守护线程，必须在start之前设置
    t.start()
print("cost time:",time.time()-start_time)
# 主线程不是守护线程，程序会等主线程执行完之后，不会等待守护线程，也就是子线程，就直接程序退出了

Part5 使用全局解释器锁

# 设置全局解释器锁
import threading
import time

def run(n):
    lock.acquire()  # 设置锁
    print("th:",n)
    global num
    num += 1
    lock.release()  # 释放锁
    time.sleep(2)

lock = threading.Lock()  # 生成一个锁
num = 0
start_time = time.time()
for i in range(50):
    t = threading.Thread(target=run,args=("t%d" %i,))
    t.start()
print(num)
print("cost time:",time.time()-start_time)

Part6 使用递归锁

import threading, time

def run1():
    print("grab the first part data")
    lock.acquire()
    global num
    num += 1
    lock.release()
    return num

def run2():
    print("grab the second part data")
    lock.acquire()
    global num2
    num2 += 1
    lock.release()
    return num2

def run3():
    lock.acquire()
    res = run1()
    print('--------between run1 and run2-----')
    res2 = run2()
    lock.release()
    print(res, res2)

num, num2 = 0, 0
lock = threading.RLock()  # 定义递归锁
for i in range(10):
    t = threading.Thread(target=run3)
    t.start()

while threading.active_count() != 1:
    print(threading.active_count())
else:
    print('----all threads done---')
    print(num, num2)

Part7 信号量

# 信号量 一般用于连接池，并发数
import threading, time

def run(n):
    semaphore.acquire()
    time.sleep(1)
    print("run the thread: %s
" % n)
    semaphore.release()

if __name__ == '__main__':
    semaphore = threading.BoundedSemaphore(5)  # 最多允许5个线程同时运行，并非5个执行完了再执行下5个，是保持在5个
    for i in range(22):
        t = threading.Thread(target=run, args=(i,))
        t.start()
while threading.active_count() != 1:
    pass  # print threading.active_count()
else:
    print('----all threads done---')

Part8 队列queue

import queue

q = queue.Queue()  # 实例化队列，数据先入先出
# q = queue.Queue(maxsize=3) 最多存放3个数据，put第四个时候就会卡住，等数据有被取走，就放进去
# q = queue.LifoQueue()  数据后入先出
# q = queue.PriorityQueue() 设置优先级

q.put("a")  # 存入数据
q.put(123)
#q.put("a",block=False)  # 放进数据超过指定最大数量就会报异常
#q.put("a",timeout=3)  # q满了，等待3秒还是不能放进去的话就报错
#q.put((2,"p1")) 传入元组，第一个元素是优先级，从小到大取数据
#q.put((-1,"p1"))
#q.put((6,"p1"))

print(q.qsize())  # 返回队列里元素数量
print(q.get())  # 获取一个数据，如果队列里没有数据就会卡住
#q.get(timeout=3)  # 有数据就立刻获取返回，如果没有数据就等待3秒，若依然没有数据就报异常
#q.get(block=False) # 如果队列里没有数据就会报异常，默认为True
#q.get_nowait()  # 如果队列里没有数据就会报异常

Part9 生产消费模型

import threading
import time
import queue

q = queue.Queue(maxsize=10)

def productData(name):
    i = 1
    while True:
        time.sleep(0.4)
        q.put("数据%s" %i)
        print("[%s] 生产了 数据[%s]" %(name,i))
        i += 1

def consumeData(name):
    while True:
        print("[%s] 消费了 [%s]" %(name,q.get()))
        time.sleep(1)

p = threading.Thread(target=productData,args=("p1",))
c1 = threading.Thread(target=consumeData,args=("c1",))
c2 = threading.Thread(target=consumeData,args=("c2",))
p.start()
c1.start()
c2.start()