1.信号量

import threading,time

class myThread(threading.Thread):
def run(self): if semaphore.acquire():
print(self.name)
time.sleep(3)
semaphore.release() if __name__=="__main__":
semaphore=threading.Semaphore() thrs=[]
for i in range(100):
thrs.append(myThread())
for t in thrs:
t.start()

2.同步对象

import threading,time
class Boss(threading.Thread): def run(self):
print("BOSS:今晚大家都要加班到22:00。")
print(event.isSet())# False
event.set()
time.sleep(5)
print("BOSS:<22:00>可以下班了。")
print(event.isSet())
event.set() class Worker(threading.Thread):
def run(self): event.wait()# 一旦event被设定,等同于pass print("Worker:哎……命苦啊!")
time.sleep(1)
event.clear()
event.wait()
print("Worker:OhYeah!") if __name__=="__main__":
event=threading.Event() threads=[]
for i in range(5):
threads.append(Worker())
threads.append(Boss())
for t in threads:
t.start()
for t in threads:
t.join() print("ending.....")

3.生产者消费者模型

# import time,random
# import queue,threading
#
# q = queue.Queue()
#
# def Producer(name):
# count = 0
# while count <10:
# print("making........")
# time.sleep(5)
# q.put(count)
# print('Producer %s has produced %s baozi..' %(name, count))
# count +=1
# #q.task_done()
# q.join()
# print("ok......") # def Consumer(name):
# count = 0
# while count <10:
# time.sleep(random.randrange(4))
# # if not q.empty():
# # print("waiting.....")
# #q.join()
# data = q.get()
# print("eating....")
# time.sleep(4)
#
# q.task_done()
# #print(data)
# print('\033[32;1mConsumer %s has eat %s baozi...\033[0m' %(name, data))
# # else:
# # print("-----no baozi anymore----")
# count +=1
#
# p1 = threading.Thread(target=Producer, args=('A君',))
# c1 = threading.Thread(target=Consumer, args=('B君',))
# c2 = threading.Thread(target=Consumer, args=('C君',))
# c3 = threading.Thread(target=Consumer, args=('D君',))
#
# p1.start()
# c1.start()
# c2.start()
# c3.start()

4.递归锁

import  threading
import time class MyThread(threading.Thread): def actionA(self): r_lcok.acquire() #count=1
print(self.name,"gotA",time.ctime())
time.sleep(2)
r_lcok.acquire() #count=2 print(self.name, "gotB", time.ctime())
time.sleep(1) r_lcok.release() #count=1
r_lcok.release() #count=0 def actionB(self): r_lcok.acquire()
print(self.name, "gotB", time.ctime())
time.sleep(2) r_lcok.acquire()
print(self.name, "gotA", time.ctime())
time.sleep(1) r_lcok.release()
r_lcok.release() def run(self): self.actionA()
self.actionB() if __name__ == '__main__': # A=threading.Lock()
# B=threading.Lock() r_lcok=threading.RLock()
L=[] for i in range(5):
t=MyThread()
t.start()
L.append(t) for i in L:
i.join() print("ending....")

5.进程调用

# from multiprocessing import Process
# import time
#
#
# def f(name):
# time.sleep(1)
# print('hello', name,time.ctime())
#
# if __name__ == '__main__':
# p_list=[]
# for i in range(3):
#
# p = Process(target=f, args=('alvin',))
# p_list.append(p)
# p.start()
#
# for i in p_list:
# i.join()
# print('end') from multiprocessing import Process
import time # class MyProcess(Process):
#
# # def __init__(self):
# # super(MyProcess, self).__init__()
# # #self.name = name
#
# def run(self):
# time.sleep(1)
# print ('hello', self.name,time.ctime())
# # if __name__ == '__main__':
# p_list=[]
#
#
# for i in range(3):
# p = MyProcess()
# p.daemon=True
# p.start()
# p_list.append(p)
#
# # for p in p_list:
# # p.join()
#
# print('end') # from multiprocessing import Process
# import os
# import time
#
#
# def info(title):
# print("title:", title)
# print('parent process:', os.getppid())
# print('process id:', os.getpid())
#
# def f(name):
#
# info('function f')
# print('hello', name)
from multiprocessing import Process
import os
import time
def info(title):
print("title",title)
print("parent process:",os.getppid())
print("process id:",os.getpid()) def f(name):
info('function f')
print("hello",name) if __name__ == '__main__':
info('main process line')
time.sleep(1)
print("-------")
p = Process(target=info("yuan"))
p.start()
p.join()
# if __name__ == '__main__':
#
# info('main process line')
#
# time.sleep(1)
# print("------------------")
# p = Process(target=info, args=('yuan',))
# p.start()
# p.join()

day34-python之进程调用的更多相关文章

  1. python之进程与线程

    什么是操作系统       可能很多人都会说,我们平时装的windows7 windows10都是操作系统,没错,他们都是操作系统.还有没有其他的? 想想我们使用的手机,Google公司的Androi ...

  2. Python:进程

    由于GIL的存在,python一个进程同时只能执行一个线程.因此在python开发时,计算密集型的程序常用多进程,IO密集型的使用多线程 1.多进程创建: #创建方法1:将要执行的方法作为参数传给Pr ...

  3. python笔记之调用系统命令

    python笔记之调用系统命令 目前我使用到的python中执行cmd的方式有三种 使用os.system("cmd") 该方法在调用完shell脚本后,返回一个16位的二进制数, ...

  4. python进阶------进程线程(五)

    Python中的IO模型 同步(synchronous) IO和异步(asynchronous) IO,阻塞(blocking) IO和非阻塞(non-blocking)IO分别是什么,到底有什么区别 ...

  5. python进阶------进程线程(三)

    python中的进程 1.multiprocessing模块 由于GIL的存在,python中的多线程其实并不是真正的多线程,如果想要充分地使用多核CPU的资源,在python中大部分情况需要使用多进 ...

  6. python 之进程篇

    多线程给我们的感觉 1.因为GIL的存在,一个进程的多线程同一时刻只能进去一个,感觉是假的并发 2.只适合I/O密集型的任务 3.针对计算密集型,就挂了(变成串行了) 在python中想要充分利用多核 ...

  7. Python之进程

    进程 进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础.在早期面向进程设计的计算机结构中,进程是程序的基本执行实体:在当代 ...

  8. Python之进程 3 - 进程池和multiprocess.Poll

    一.为什么要有进程池? 在程序实际处理问题过程中,忙时会有成千上万的任务需要被执行,闲时可能只有零星任务.那么在成千上万个任务需要被执行的时候,我们就需要去创建成千上万个进程么?首先,创建进程需要消耗 ...

  9. Python之进程 2 - multiprocessing模块

    ​ 我们已经了解了,运行中的程序就是一个进程.所有的进程都是通过它的父进程来创建的.因此,运行起来的python程序也是一个进程,那么我们也可以在程序中再创建进程.多个进程可以实现并发效果,也就是说, ...

  10. {Python之进程} 背景知识 什么是进程 进程调度 并发与并行 同步\异步\阻塞\非阻塞 进程的创建与结束 multiprocess模块 进程池和mutiprocess.Poll

    Python之进程 进程 本节目录 一 背景知识 二 什么是进程 三 进程调度 四 并发与并行 五 同步\异步\阻塞\非阻塞 六 进程的创建与结束 七 multiprocess模块 八 进程池和mut ...

随机推荐

  1. hangfire控制台应用程序中添加控制面板

    1.使用nuget 管理包安装 Microsoft.AspNet.WebApi.OwinSelfHost 2.根目录添加新建类 名为:Startup.cs public class Startup { ...

  2. vue+elementui搭建后台管理界面(8 同步/异步获取数据渲染table)

    elementui已经封装好了 el-table 组件,只需要指定 data 数据源即可,因此通常在 vue 实例生命周期的 created 阶段,从数据库获取数据,再将返回的数据绑定到 data 如 ...

  3. linux 的 两种磁盘扩容

    当LVM分区空间不足的时候,可以进行扩容.主要的扩容方法有两种: 通过空余的磁盘进行扩容,这个方法比较简单,不会对原有数据有影响.将其他LVM分区空间取出一部分给需要扩容的LVM分区.下面就分别具体介 ...

  4. java查看线程的堆栈信息

    通过使用jps 命令获取需要监控的进程的pid,然后使用jstack pid 命令查看线程的堆栈信息. 通过jstack 命令可以获取当前进程的所有线程信息. 每个线程堆中信息中,都可以查看到线程ID ...

  5. np.concatenate

  6. 【交互】抖音VS快手

    从能量节约,懒惰的人性本质角度来分析,有点意思. https://www.ui.cn/detail/506135.html

  7. centos7.3部署memcached服务

    我们需要下载libevent和memcached这两个压缩包进行安装,可使用以下百度网盘链接进行下载 链接:https://pan.baidu.com/s/1vehZ5odzXFKwNjWT9_W0T ...

  8. [LeetCode] 3.Longest Substring Without Repeating Characters 最长无重复子串

    Given a string, find the length of the longest substring without repeating characters. Example 1: In ...

  9. python:单例模式--使用__new__(cls)实现

    单例模式:即一个类有且仅有一个实例. 那么通过python怎么实现一个类只能有一个实例呢. class Earth: """ 假如你是神,你可以创造地球 "&q ...

  10. redis如何实现主从数据的同步

    Redis的主从同步机制可以确保redis的master和slave之间的数据同步.按照同步内容的多少可以分为全同步和部分同步:按照同步的时机可以分为slave刚启动时的初始化同步和正常运行过程中的数 ...