doraemon的python 守护进程和Process

### 9.4 Process模块    进程

```python
from multiprocess import Process
p = Process(target=函数名,args=(参数1,))

1.如何创建一个进程对象
    对象和进程之间的关系:
    a.进程对象和进程并没有直接的关系
    b.只是存储了一些和进程相关的内容
    c.此时此刻,操作系统还没有接收到创建进程的指令

2.如何开启一个进程
    通过p.start()开启一个进程,这个方法相当于给操作系统一个开启指令指令
    start方法的异步非阻塞的特点:
        a.在执行这个方法的时候,我们既不等待进程开启,也不等待操作系统给我们的想要
        b.这里只是负责同志操作系统去开启一个进程
        开启一个子进程之后,主进程和子进程的代码完全异步

3.父进程和子进程之间的关系
    a.父进程会等待子进程结束之后才结束
    b.是为了挥手子进程的资源

4.不同操作系统中进程开启的方式
    windows 通过(模块导入)再一次执行父进程文件中的代码来获取父进程中的数据
    所以只要是不希望被子进程执行的代码,就写在if __name__ == ‘__main__‘下
     因为在进行导入的时候父进程文件中的__name__ != ‘__main__‘
     linux/ios
     正常的写就可以,没有if __name__ == ‘__main__‘这件事情了
5.如何确认一个子进程执行完毕
        join方法
        开启了多个子进程,等待所有子进程结束

```

#### 9.4.1 守护进程

```python
def son1(a,b):
    while True:
        print(‘is alive‘)
        time.sleep(0.5)

def son2():
    for i in range(5):
        print(‘in son2‘)
        time.sleep(1)

if __name__ == "__main__":
    p = PROcess(target=son1,args=(1,2))
    p.daemon = True
    p.start()
    p2 = Process(target=son2)
    p2.start()
    time.sleep(2)

#守护进程是随着主进程的代码结束而结束
    生产者消费者模型的时候
    守护线程做对比的时候
#所有子进程都必须在主进程结束之前结束,由主进程挥手资源
```

```python
# 有一个参数可以把一个子进程设置为一个守护进程
import time
from multiprocessing import Process

def son1():
    while True:
        print(‘is alive‘)
        time.sleep(0.5)

if __name__ == ‘__main__‘:
    p = Process(target=son1)
    p.start()      # 异步 非阻塞
    print(p.is_alive())
    time.sleep(1)
    p.terminate()   # 异步的 非阻塞
    print(p.is_alive())   # 进程还活着 因为操作系统还没来得及关闭进程
    time.sleep(0.01)
    print(p.is_alive())   # 操作系统已经响应了我们要关闭进程的需求,再去检测的时候,得到的结果是进程已经结束了

# 什么是异步非阻塞?
    # terminate

```

#### 9.4.2 面向对象方式的守护进程

#### 9.4.3 Process类的总结

```python
# Process类
# 开启进程的方式
    # 面向函数
        # def 函数名:要在子进程中执行的代码
        # p = Process(target= 函数名,args=(参数1,))

    #面向对象
        #class 类名(Process):
            #def __init__(self,参数1,参数2):
                #self.a = 参数1
                #self.b = 参数2
                #super().__init__()
            #def run(self):
                #需要在紫禁城中执行的代码
        #p = 类名(参数1,参数2)
        #p.start()   异步非阻塞
        #p.terminate()   异步非阻塞
        #p.join()    同步阻塞
        #p.isalive()    获取当前进程状态
        #daemon = True 设置为守护进程,守护进程会在主进程代码结束后结束
```

#### 

### 9.5 锁

#### 9.5.1 什么时候需要用锁

- 如果在一个并发条件下,涉及的某部分内容
  - 是需要修改一些所有进程共享的数据资源
  - 需要枷锁类维持数据的安全
- 在数据安全的基础上,才考虑效率问题
- 同步存在的意义
  - 数据安全

#### 9.5.2 锁在代码中的应用顺序

- 在主进程中实例化lock = Lock()
- 把这把锁传递给子进程
- 在子进程中 对需要枷锁的代码进行with lock:
  - with lock 相当于lock.acquire()和lock.release()
- 在主进程需要加锁的场景:
  - 共享数据资源(文件、数据等)
  - 对资源进行修改删除操作
- 加锁之后能保证数据的安全性 但同时也降低了程序的执行效率

```python
import time
import json
from multiprocessing import Process,Lock

def search_ticket(user):
    with open(‘ticket_count‘) as f:
        dic = json.load(f)
        print(‘%s查询结果  : %s张余票‘%(user,dic[‘count‘]))

def buy_ticket(user,lock):
    # with lock:
    # lock.acquire()   # 给这段代码加上一把锁
        time.sleep(0.02)
        with open(‘ticket_count‘) as f:
            dic = json.load(f)
        if dic[‘count‘] > 0:
            print(‘%s买到票了‘%(user))
            dic[‘count‘] -= 1
        else:
            print(‘%s没买到票‘ % (user))
        time.sleep(0.02)
        with open(‘ticket_count‘,‘w‘) as f:
            json.dump(dic,f)
    # lock.release()   # 给这段代码解锁

def task(user, lock):
    search_ticket(user)
    with lock:
        buy_ticket(user, lock)

if __name__ == ‘__main__‘:
    lock = Lock()
    for i in range(10):
        p = Process(target=task,args=(‘user%s‘%i,lock))
        p.start()
```

#### 9.5.3 进程之间的通信(IPC)

```python
# 通信
 #进程之间的通信 - IPC(inter process communication)
 from multiprocessing import Queue,Process
 # 先进先出
 def func(exp,q):
     ret = eval(exp)
     q.put({ret,2,3})
     q.put(ret*2)
     q.put(ret*4)

 if __name__ == ‘__main__‘:
     q = Queue()
     Process(target=func,args=(‘1+2+3‘,q)).start()
     print(q.get())
     print(q.get())#     print(q.get())

# Queue基于 天生就是数据安全的
    # 文件家族的socket pickle lock
# pipe 管道(不安全的) = 文件家族的socket pickle
# 队列 = 管道 + 锁

```

原文地址:https://www.cnblogs.com/doraemon548542/p/11421654.html

时间: 2024-10-11 07:06:03

doraemon的python 守护进程和Process的相关文章

Python实例浅谈之五Python守护进程和脚本单例运行

一.简介 守护进程最重要的特性是后台运行:它必须与其运行前的环境隔离开来,这些环境包括未关闭的文件描述符.控制终端.会话和进程组.工作目录以及文件创建掩码等:它可以在系统启动时从启动脚本/etc/rc.d中启动,可以由inetd守护进程启动,也可以有作业规划进程crond启动,还可以由用户终端(通常是shell)执行. Python有时需要保证只运行一个脚本实例,以避免数据的冲突. 二.Python守护进程 1.函数实现 #!/usr/bin/env python #coding: utf-8

#python#守护进程的实现

找了整天,终于找到一个可以用的代码 #! /usr/bin/env python2.7 #encoding:utf-8 #@description:一个python守护进程的例子 #@tags:python,daemon import sys import os import time import atexit from signal import SIGTERM      class Daemon:   """   A generic daemon class.     

python 守护进程

daemon进程 守护进程 1.fork子进程,而后父进程退出,此时子进程会被init进程接管 2.修改子进程的工作目录,创建新进程组和新会话,修改umask 3.子进程再次fork一个进程,这个进程可以称为孙子进程,而后子进程退出 4.重定向孙子进程标准输入流,标准输出等 atexit程序退出 调用某个函数 kill  级别 python 守护进程,布布扣,bubuko.com

Python守护进程(多线程开发)

#!/usr/bin/python import sys,time,json,logging import Queue, threading, datetime from lib.base.daemon import Daemon from lib.queue.httpsqs.HttpsqsClient import HttpsqsClient from lib.db.DbMongodb import DbMongodb logging.basicConfig(level=logging.DEB

Python守护进程命令,为何被黑客钟意?整蛊、木马都用得上它!

考虑一下利用Python制作一个整蛊.木马软件,我提供思路.(清楚到没学过编程的人也理解) 1.首先一个黑客做一个整蛊或者木马软件,一定不会让你能够关闭它. 2.里面经常会附带欺骗的方法. 3.最终实现某种目的. 前段时间在抖音上看到个有趣的程序,看样子是VB写的,首先就要用到欺骗的方法,利用软件名称欺骗目标点击软件,打开后出现一个标签.两个按钮. 标签上写的是:我爱你,你爱我吗? 按钮:一个写爱,一个是不爱. 怎么办?一般人看到这种情况就直接点叉关闭软件了.然而人家程序员早就在代码里写了 窗口

041.Python守护进程,锁信号量和事件

一 守护进程 1.1 基本概念 守护进程 正常情况下,主进程默认等待子进程调用结束之后结束 守护进程在主进程执行代码结束后,自动终止 守护进程语法: 进程对象.daemon = True ,设置该进程是守护进程 守护进程需要在start()方法之前设置 为主进程守护,主进程如果代码执行结束了,该守护进程自动结束. 1.2 基本语法 import os import time from multiprocessing import Process def func(): print("子进程sta

python 守护进程(daemon)

#!/usr/bin/env python # -*- coding:utf-8 -*- import sys, os '''将当前进程fork为一个守护进程    注意:如果你的守护进程是由inetd启动的,不要这样做!inetd完成了    所有需要做的事情,包括重定向标准文件描述符,需要做的事情只有chdir()和umask()了 ''' def daemon(stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):     #

python守护进程--->deamon

1.守护进程: (1)守护进程会在主进程结束的时候立马结束 (2)守护进程要设置在start之前 (3)守护进程能不能再开启子进程,否则会报错.(错误:AssertionError: daemonic processes are not allowed to have children) 代码例子: from multiprocessing import Process import time def work(name): print('task <%s> is runing' %name)

linux下python守护进程编写和原理理解

原文地址: http://www.01happy.com/linux-python-daemon/ 守护进程英文为daemon,像httpd.mysqld.vsftpd最后个字母d其实就是表示daemon的意思. 守护进程的编写步骤: fork子进程,而后父进程退出,此时子进程会被init进程接管. 修改子进程的工作目录.创建新进程组和新会话.修改umask. 子进程再次fork一个进程,这个进程可以称为孙子进程,而后子进程退出. 重定向孙子进程的标准输入流.标准输出流.标准错误流到/dev/n