Python之路，day10-Python基础

一、进程
进程：一个程序要运行时所需的所有资源的集合
      进程是资源的集合，相当于一个车间

      一个进程至少需要一个线程，这个线程为主线程
      一个进程里可以有多个线程

      cpu cores越多，代表着你可以真正并发的线程越多

      2个进程之间的数据是完全独立的，互相不能访问
1.进程lock

from multiprocessing import Process, Lock


def f(l, i):
    l.acquire()
    try:
        print('hello world', i)
    finally:
        l.release()


if __name__ == '__main__':
    lock = Lock()

    for num in range(10):
        Process(target=f, args=(lock, num)).start()

2.进程池

from multiprocessing import Process, Lock,Pool
import time

def f(i):
    # l.acquire()
    # try:
        print('hello world  %s'%i)
        time.sleep(1)
    # finally:
    #     l.release()
        return i

def Bar(data):
    print(data)
if __name__ == '__main__':
    lock = Lock()
    pool = Pool(processes=5)
    for num in range(10):
        # Process(target=f, args=(lock, num)).start()
        pool.apply_async(func=f,args=(num,),callback=Bar)
    pool.close()
    pool.join()

3.进程间通信

from multiprocessing import Process, Queue


def f(q):
    q.put([42, None, 'hello'])


if __name__ == '__main__':
    q = Queue()
    p = Process(target=f, args=(q,))
    p.start()
    print(q.get())  # prints "[42, None, 'hello']"
    p.join()

3.多进程

from multiprocessing import Process
import time


def f(name):
    time.sleep(2)
    print('hello', name)


if __name__ == '__main__':
    for i in range(10):
        p = Process(target=f, args=('bob',))
        p.start()
        # p.join()

二、线程
线程：
      一个单一的指令的控制流，寄生在进程中

      单一进程里的多个线程是共享数据的

      多线程在涉及修改同一数据时一定要加锁

     自己总结：（宏观并发，时间片切换比进程快），多核编程
1.线程

import threading
import time
def run(n):
    time.sleep(1)
    # print(threading.get_ident())
    print("thread",n)
    print(threading.current_thread())
for i in range(10):
    t = threading.Thread(target=run, args=(i,))
    t.start()
    # t.setName(i)
    print(t.getName())

print(threading.active_count())
# t = threading.Thread(target=run,args=(1,))
# t.start()
# t2 = threading.Thread(target=run,args=(2,))
# t2.start()
print(threading.current_thread())
time.sleep(1.5)

print(threading.active_count())

2.线程lock.py

import threading
import time
def run(n):
    global num
    l.acquire()#获取锁
    num = num + 1
    time.sleep(1)
    l.release()#释放锁
    print(num)
    # print("thread",n)
def run2():
    count = 0
    while num < 9:
        print('---', count)
        count +=1

l = threading.Lock()   #定义锁

num = 0
t_list = []
for i in range(10):
    t = threading.Thread(target=run, args=(i,))
    t.start()
    t_list.append(t)
t2 = threading.Thread(target=run2)
t2.start()

for t in t_list:
    t.join()

print('----main Thread----')
print(num)

3.线程等待

import threading
import time
def run(n):
    time.sleep(1)
    print("thread",n)

t_list = []

for i in range(10):
    t = threading.Thread(target=run, args=(i,))
    t.start()
    t_list.append(t)
# t.join()
for t in t_list:
    t.join()

print('----main Thread----')

生产者消费者的两个主要作用
1.程序的解耦合，异步
2.提高了程序的运行效率

import threading
import  queue
import time
def consumer(name):

    while True:
        print("%s 取到骨头[%s]吃了" %(name,q.get()))
        time.sleep(0.5)
        q.task_done()
def producer(name):
    count = 0
    # while q.qsize() < 5:
    for i in range(10):
        print("%s生成了骨头"%name,count)
        q.put(count)
        count +=1
        time.sleep(0.3)
    q.join()
    print("------chiwan--------")
q = queue.Queue(maxsize = 4)

p = threading.Thread(target=producer,args=('alex',))
# p2 = threading.Thread(target=producer,args=('aaa',))
c = threading.Thread(target=consumer,args=('qqq',))
p.start()
# p2.start()
c.start()