总结二十七

Posted tzz1995

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了总结二十七相关的知识,希望对你有一定的参考价值。

进程间通信

# from threading import Thread
# import time
#
# def task(name):
#     print(‘%s is running‘%name)
#     time.sleep(3)
#     print(‘%s is over‘%name)
# # 开线程不需要在__main__代码块内 但是习惯性的还是写在__main__代码块内
# t = Thread(target=task,args=(‘egon‘,))
# t.start()  # 告诉操作系统开辟一个线程  线程的开销远远小于进程
# # 小的代码执行完 线程就已经开启了
# print(‘主‘)


from threading import Thread
import time

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

    def run(self):
        print(%s is running%self.name)
        time.sleep(3)
        print(%s is over%self.name)

t = MyThread(egon)
t.start()
print()

 

进程间通信IPC机制

from multiprocessing import Process,Queue

def producer(q):
    q.put(hello GF~)

def consumer(q):
    print(q.get())

if __name__ == __main__:
    q = Queue()
    p = Process(target=producer,args=(q,))
    c = Process(target=consumer, args=(q,))
    p.start()
    c.start()


"""
子进程放数据 主进程获取数据
两个子进程相互放 取数据
"""

 

生产者消费者模型

"""
生产者:生产/制造数据的
消费者:消费/处理数据的
例子:做包子的,买包子的
        1.做包子远比买包子的多
        2.做包子的远比包子的少
        供需不平衡的问题
"""
from multiprocessing import Process,Queue,JoinableQueue
import random
import time


def producer(name,food,q):
    for i in range(10):
        data = %s生产了%s%s%(name,food,i)
        time.sleep(random.random())
        q.put(data)
        print(data)

def consumer(name,q):
    while True:
        data = q.get()
        if data == None:break
        print(%s吃了%s%(name,data))
        time.sleep(random.random())
        q.task_done()  # 告诉队列你已经从队列中取出了一个数据 并且处理完毕了


if __name__ == __main__:
    q = JoinableQueue()

    p = Process(target=producer,args=(大厨egon,馒头,q))
    p1 = Process(target=producer,args=(跟班tank,生蚝,q))
    c = Process(target=consumer,args=(许兆龙,q))
    c1 = Process(target=consumer,args=(吃货jerry,q))
    p.start()
    p1.start()
    c.daemon = True
    c1.daemon = True
    c.start()
    c1.start()
    p.join()
    p1.join()

    q.join()  # 等到队列中数据全部取出
    # q.put(None)
    # q.put(None)

 

线程

什么是线程

  进程线程其实都是虚拟单位,都是用来帮助我们形象的秒数某种事物

  进程:资源单位

  线程:执行单位

    将内存比喻成工厂

    那么进程就相当于是工厂里面的车间

    而你的线程就相当于是车间里面的流水线

  ps:每个进程都自带一个线程,线程才是真正的执行单位,进程只是在线程运行过程中提供代码运行所需要的资源

 

为什么要有线程

  开进程

    1.申请内存空间   耗资源

    2.‘拷贝代码’         耗资源

  开线程

    一个进程内可以起多个线程,并且线程与线程之间数据是共享的

  ps:开启线程的开销要远远小于开启进程的开销

 

如何使用线程

创建线程的两种方式

from threading import Thread
import time

def task(name):
    print(%s is running%name)
    time.sleep(3)
    print(%s is over%name)
# 开线程不需要在__main__代码块内 但是习惯性的还是写在__main__代码块内
t = Thread(target=task,args=(egon,))
t.start()  # 告诉操作系统开辟一个线程  线程的开销远远小于进程
# 小的代码执行完 线程就已经开启了
print()
from threading import Thread
import time

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

    def run(self):
        print(%s is running%self.name)
        time.sleep(3)
        print(%s is over%self.name)

t = MyThread(egon)
t.start()
print()

 

线程对象及其他方法

from threading import Thread,current_thread,active_count
import time
import os

def task(name,i):
    print(%s is running%name)
    # print(‘子current_thread:‘,current_thread().name)
    # print(‘子‘,os.getpid())
    time.sleep(i)

    print(%s is over%name)
# 开线程不需要在__main__代码块内 但是习惯性的还是写在__main__代码块内
t = Thread(target=task,args=(egon,1))
t1 = Thread(target=task,args=(jason,2))
t.start()  # 告诉操作系统开辟一个线程  线程的开销远远小于进程
t1.start()  # 告诉操作系统开辟一个线程  线程的开销远远小于进程
t1.join()  # 主线程等待子线程运行完毕
print(当前正在活跃的线程数,active_count())
# 小的代码执行完 线程就已经开启了
print()
# print(‘主current_thread:‘,current_thread().name)
# print(‘主‘,os.getpid())

 

守护线程

from threading import Thread,current_thread
import time

def task(i):
    print(current_thread().name)
    time.sleep(i)
    print(GG)
# for i in range(3):
#     t = Thread(target=task,args=(i,))
#     t.start()
t = Thread(target=task,args=(1,))
t.daemon = True
t.start()
print()
# 主线程运行结束之后需要等待子线程结束才能结束呢?
"""
主线程的结束也就意味着进程的结束
主线程必须等待其他非守护线程的结束才能结束
(意味子线程在运行的时候需要使用进程中的资源,而主线程一旦结束了资源也就销毁了)
"""

 

线程间通信

from threading import Thread

money = 666

def task():
    global money
    money = 999

t = Thread(target=task)
t.start()
t.join()
print(money)

 

互斥锁

from threading import Thread,Lock
import time

n = 100

def task(mutex):
    global  n
    mutex.acquire()
    tmp = n
    time.sleep(0.1)
    n = tmp - 1
    mutex.release()

t_list = []
mutex = Lock()
for i in range(100):
    t = Thread(target=task,args=(mutex,))
    t.start()
    t_list.append(t)
for t in t_list:
    t.join()
print(n)

 

以上是关于总结二十七的主要内容,如果未能解决你的问题,请参考以下文章

-考研第二十七周总结-

-考研第二十七周总结-

马哥教育二十七至三十天学习总结

Android项目实战(二十七):数据交互(信息编辑)填写总结

GUI学习之二十七——布局管理学习总结

Linux学习总结(二十七)任务计划,系统服务管理