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()