学习日记0906 进程间通信(IPC机制) 消费者生产者模型 线程的基本理论

进程间通信IPC机制　　

　　

from multiprocessing import Queue

p= Queue()
p.put('123')
p.put('456')
print(p.get())
print(p.get())

　　IPC机制用白话讲其实就是开辟了一个公共的内存空间,由于进程在内存中是隔离,所以开辟了这个空间以后我们就可以在进程间进行通信了,这个空间我们俗称为管道

生产者与消费者模型

　　该模型的原理非常的简单:就是两个进程这间通过IPC机制进行通信,并且保证这两个进程是并发的

简单的生产者与消费者模型:

from multiprocessing import Process,JoinableQueue

def producer(name,p):
    for i in range(10):
        msg = '%s %s' %(name,i)
        p.put(msg)
        print('生产者生产了%s' % (msg))

def consumer(name,p):
    while True:
        msg = p.get()
        print("消费者%s 消费了%s" % (name, msg))
        p.task_done()

if __name__ == '__main__':
    p = JoinableQueue()
    pro = Process(target=producer,args=('a',p))
    cons = Process(target=consumer,args=('xfz',p))
    pro.start()
    cons.start()
    pro.join()
    cons.join()
    p.join()
    print('主进程')

开启线程的两种方式:

方式一:

　　

from threading import Thread

def task():
    print('线程已经开启!')


if __name__ == '__main__':
    ta = Thread(target=task)
    ta.start()
    print('主线程!')

方式二(开启线程时与开启进程是相似,就是调用Thread下的run方法):

from threading import Thread

class Mythread(Thread):
    def run(self):
        print('线程已经开启!')


if __name__ == '__main__':
    t= Mythread()
    t.start()
    print('zhu')

线程的特性

　　在此简单的介绍一下进程的几种内置方法:

　　　　.join()(等待子线程运行结束之后再运行主线程相当于等待)

　　　　os.getpid()(得到线程的pid)

　　　　active_count()(获取当前线程数)

守护线程

　　

from threading import Thread
from multiprocessing import Process
import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")

if __name__ == '__main__':
    # t1=Thread(target=foo)
    # t2=Thread(target=bar)

    t1=Process(target=foo)
    t2=Process(target=bar)
    t1.daemon=True
    t1.start()
    t2.start()
    print("main-------")

线程互斥锁

from threading import Thread,Lock

n = 100
mutex = Lock()
def task():
    global n
    with mutex:
        t = n
        # time.sleep(0.01)
        n = t-1

if __name__ == '__main__':
    t_l = []
    for i in range(100):
        t= Thread(target=task)
        t_l.append(t)
        t.start()
    for i in t_l:
        i.join()

    print(n)