线程和进程

操作系统/应用程序

硬件，硬盘、cpu、主板、显卡、内存、电源... ...

装系统（软件）

系统就是由一个程序员写出来软件，该关键用于控制计算机的硬件，让他们之间进行相互配合

软件安装（安装应用程序）

qq  360  百度云   pycharm

并发和并行

并发，伪，由于执行速度特别快，人感觉不到停顿。

并行，真，创建10个人同时操作。

进程和线程

单进程、单线程的应用程序

print("666")

　　到底什么是线程？什么是进程？

Python自己没有这玩意，Python中调用的操作系统的线程和进程。

单线程、多线程的应用程序

import threading
print("666")

def func(arg):
      print(arg)
t = threading.Thread(target=func)
t.start()

print("end")

　python线程编写

import threading
v1 = [11,22,33]
v2 = [44,55,66]

def func(data,plus):
     for i in range(len(data)):
          data[i] = data[i] + plus

t1 = threading.Thread(target=func,args=(v1,1))
t1.start()

t2 = threading.Thread(target=func,args=(v2,100))
t2.start()

python锁

python的GIL锁

python内置一个全局解释器锁，锁的作用就是保证同一时刻一个进程中只有一个线程可以被cpu调用

线程锁：由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁 - 同一时刻允许一个线程执行操作。

 lock/Rlock   一次放1个

import threading
import time

v = []
lock = threading.Lock()

def func(arg):
    lock.acquire()
    v.append(arg)
    time.sleep(0.01)
    m = v[-1]
    print(arg,m)
    lock.release()


for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()


v = []
lock = threading.RLock()
def func(arg):
    lock.acquire()
    lock.acquire()

    v.append(arg)
    time.sleep(0.01)
    m = v[-1]
    print(arg,m)

    lock.release()
    lock.release()


for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()

　　BoundedSemaphore（1次放N个）信号量

import time
import threading

lock = threading.BoundedSemaphore(3)
def func(arg):
    lock.acquire()
    print(arg)
    time.sleep(1)
    lock.release()


for i in range(20):
    t =threading.Thread(target=func,args=(i,))
    t.start()

　　condition锁，一次放n个

import time
import threading

lock = threading.Condition()

# ############## 方式一 ##############

def func(arg):
    print('线程进来了')
    lock.acquire()
    lock.wait() # 加锁

    print(arg)
    time.sleep(1)

    lock.release()


for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()

while True:
    inp = int(input('>>>'))

    lock.acquire()
    lock.notify(inp)
    lock.release()


# ############## 方式二 ##############
"""
def xxxx():
    print('来执行函数了')
    input(">>>")
    # ct = threading.current_thread() # 获取当前线程
    # ct.getName()
    return True

def func(arg):
    print('线程进来了')
    lock.wait_for(xxxx)
    print(arg)
    time.sleep(1)

for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()

"""

 锁Event    一次全部放　　

import time
import threading

lock = threading.Event()


def func(arg):
    print('线程来了')
    lock.wait() # 加锁：红灯
    print(arg)


for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()

input(">>>>")
lock.set() # 绿灯


lock.clear() # 再次变红灯

for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()

input(">>>>")
lock.set()

 为什么要加锁：

非线程安全

控制一段代码

threading.local

作用：内部自动为每个线程维护一个空间（字典），用于当前存取属于自己的值。保证线程之间的数据隔离。

 示例：

import time
import threading

v = threading.local()
def func(arg):
    # 内部会为当前线程创建一个空间用于存储：phone=自己的值
    v.phone = arg
    time.sleep(2)
    print(v.phone,arg) # 去当前线程自己空间取值

for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()

　　线程池

生产者消费者模型

三部件：

生产者

队列，先进先出

扩展：栈，后进先出

消费者

问：生产者消费者模型解决了什么问题？

不用一直等待的问题。

import time
import queue
import threading
q = queue.Queue() # 线程安全

def producer(id):
    """
    生产者
    :return:
    """
    while True:
        time.sleep(2)
        q.put('包子')
        print('厨师%s 生产了一个包子' %id )

    for i in range(1,4):
        t = threading.Thread(target=producer,args=(i,))
        t.start()


    def consumer(id):
    """
    消费者
    :return:
    """
    while True:
        time.sleep(1)
        v1 = q.get()
        print('顾客 %s 吃了一个包子' % id)

    for i in range(1,3):
	t = threading.Thread(target=consumer,args=(i,))
	t.start()                

 

进程 ：

进程间数据不共享

data_list = []

def task(arg):
    data_list.append(arg)
    print(data_list)


def run():
    for i in range(10):
        p = multiprocessing.Process(target=task,args=(i,))
        # p = threading.Thread(target=task,args=(i,))
        p.start()

if __name__ == '__main__':
    run()

　常用功能：

join、deamon、name、multiprocessing.current_process()、multiprocessing.current_process().ident/pid

 类继承方式创建进程：

import multiprocessing
class MyProcess(multiprocessing.Process):

    def run(self):
        print('当前进程',multiprocessing.current_process())


def run():
    p1 = MyProcess()
    p1.start()

    p2 = MyProcess()
    p2.start()

if __name__ == '__main__':
    run()

　　进程间数据共享：

Queue:
linux:
	q = multiprocessing.Queue()

	def task(arg,q):
		q.put(arg)

	def run():
		for i in range(10):
			p = multiprocessing.Process(target=task, args=(i, q,))
			p.start()

		while True:
			v = q.get()
			print(v)

	run()
windows:	
def task(arg,q):
	q.put(arg)

if __name__ == '__main__':
	q = multiprocessing.Queue()
	for i in range(10):
		p = multiprocessing.Process(target=task,args=(i,q,))
		p.start()
	while True:
		v = q.get()
		print(v)
	
Manager:（*）
Linux:
	m = multiprocessing.Manager()
	dic = m.dict()

	def task(arg):
		dic[arg] = 100

	def run():
		for i in range(10):
			p = multiprocessing.Process(target=task, args=(i,))
			p.start()

		input('>>>')
		print(dic.values())
		
	if __name__ == '__main__':
		
		run()
windows:
	def task(arg,dic):
		time.sleep(2)
		dic[arg] = 100

	if __name__ == '__main__':
		m = multiprocessing.Manager()
		dic = m.dict()

		process_list = []
		for i in range(10):
			p = multiprocessing.Process(target=task, args=(i,dic,))
			p.start()

			process_list.append(p)

		while True:
			count = 0
			for p in process_list:
				if not p.is_alive():
					count += 1
			if count == len(process_list):
				break
		print(dic)

 进程锁

import time
import threading
import multiprocessing


lock = multiprocessing.RLock()

def task(arg):
    print('鬼子来了')
    lock.acquire()
    time.sleep(2)
    print(arg)
    lock.release()


if __name__ == '__main__':
    p1 = multiprocessing.Process(target=task,args=(1,))
    p1.start()

    p2 = multiprocessing.Process(target=task, args=(2,))
    p2.start()

　　为什么要加锁？？

进程池

import time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

def task(arg):
    time.sleep(2)
    print(arg)

if __name__ == '__main__':

    pool = ProcessPoolExecutor(5)
    for i in range(10):
        pool.submit(task,i)