进程和线程的一个区别

进程和线程的一个区别

linux下查看进程的命令：ps -ef|grep xxx
[root@iZ2zejbxp2btn9jh8knipuZ ~]# ps -ef|grep python
root 7717 7665 0 21:05 pts/0 00:00:00 grep python
root 16527 1 0 Aug16 ? 04:01:07 python run.py

windows下查看进程的方式：
1）从任务管理器中查看进程

程序不是进程，只有程序处于运行时才算进程。

进程、线程与处理器的调度
https://www.cnblogs.com/ChunJian-YANG/p/5506209.html

进程间通讯：两个进程之间互相发送消息

进程：独立性，制约性

同步方法调用一旦开始，调用者必须等到方法调用返回后，才能继续后续的行为。
异步方法调用更像一个消息传递，一旦开始，方法调用就会立即返回，调用者就可以继续后续的操作。而，异步方法通常会在另外一个线程中，“真实”地执行着。整个过程，不会阻碍调用者的工作。

同步：必须按顺序执行，每个步骤间存在依赖关系。

异步：可以不按顺序执行，每个步骤间不存在依赖关系，可通过多线程实现。

什么时候用同步？ 有依赖关系，无依赖关系
什么使用异步？ 无依赖关系

有依赖关系的时候只能用同步，没有依赖关系的时候，可同步，可异步

CPU 按照时间片不停的上下文切换

一个进程至少有一个线程
进程是分配资源的基本单位，所有的线程都是共享一个进程的所有的资源

两个建立通信，互相告知对方运行次数
两个个进程可以设置全局共享变量，进程间
两个进程都写一个文件

进程的调度效率很低，线程的调用效率高

python 实现并发使用多进程并发的方式，而不是线程并发的方式。

多线程和多进程实现的并发效果

python实现并发的方式
1）多进程----用到多核CPU，并发需要使用多核CPU使用
2）多线程----只能用单核CPU（GIL），并发产生很多I/O使用
2）协程----本质单线程，只能使用单核CPU，能自动识别I/O的时候，当发现线程有I/O时不会等待，会跳到别的不需要I/O的线程去执行

fork(…)
fork() -> pid

Fork a child process.
Return 0 to child process and PID of child to parent process.

os.fork()规定，主进程自动获取函数返回值是子进程的pid
子进程获取函数返回值是0

Linux 下通过fork生成进程
“”"
pid=os.fork()
1.只用在Unix系统中有效，Windows系统中无效
2.fork函数调用一次，返回两次：
在父进程中返回值为子进程id，在子进程中返回值为0
“”"

import os

pid=os.fork() #主进程生成了一个子进程，出现了2个进程同时开始向下执行。
#主进程获取的子进程的pid号；子进程拿的是自己的pid号，pid号为0(为什么是0，子进程拿到的pid就是0）

if pid==0:
print(“执行子进程，子进程pid={pid},父进程ppid={ppid}”.\ #子进程执行这段代码
format(pid=os.getpid(),ppid=os.getppid()))
else:
print(“执行父进程，子进程pid={pid},父进程ppid={ppid}”.\ #主进程执行这段代码
format(pid=pid,ppid=os.getpid()))

最后这段代码执行结果为：
执行父进程，子进程pid={pid},父进程ppid={ppid}
执行子进程，子进程pid={pid},父进程ppid={ppid}

逻辑上if…else都可以先执行，只是子进程创建后需要初始化后才能使用，相对而言主程序可以更快执行，所以看到的执行结果，是else优先。

“”"
Process常用属性与方法：
name:进程名
pid：进程id
run()，自定义子类时覆写
start()，开启进程
join(timeout=None)，阻塞进程
terminate(),终止进程
is_alive()，判断进程是否存活
“”"

import os,time
from multiprocessing import Process

def worker():
print(“子进程执行中>>> pid={0},ppid={1}”.format(os.getpid(),os.getppid()))
time.sleep(2)
print(“子进程终止>>> pid={0}”.format(os.getpid()))

def main():
print(“主进程执行中>>> pid={0}”.format(os.getpid()))#获取当前进程的进程号

ps=[]
# 创建子进程实例
for i in range(2):
    p=Process(target=worker,name="worker"+str(i),args=()) #args=()表示传递参数，生成的子进程调用worker函数
    ps.append(p)

# 开启进程
for i in range(2):
    ps[i].start()

# 阻塞进程
for i in range(2):
    ps[i].join()  #子进程执行完毕后，才能让主进程执行

print("主进程终止")

if name == ‘main’: #如果程序当做模块被引用时，main()不会执行；如果程序
main() 本身执行时，才会执行main()

执行结果：
主进程执行中>>> pid=7748
子进程执行中>>> pid=7524,ppid=7748
子进程执行中>>> pid=11904,ppid=7748
子进程终止>>> pid=7524
子进程终止>>> pid=11904
主进程终止

“”"
Process常用属性与方法：
name:进程名
pid：进程id
run()，自定义子类时覆写
start()，开启进程
join(timeout=None)，阻塞进程
terminate(),终止进程
is_alive()，判断进程是否存活
“”"

import os, time
from multiprocessing import Process

def worker():
print(“子进程执行中>>> pid={0},ppid={1}”.format(os.getpid(), os.getppid()))
time.sleep(2)
print(“子进程终止>>> pid={0}”.format(os.getpid()))

def main():
print(“主进程执行中>>> pid={0}”.format(os.getpid()))

ps = []
# 创建子进程实例
for i in range(2):
    p = Process(target=worker, name="worker" + str(i), args=())
    ps.append(p)

# 开启进程
for i in range(2):
    ps[i].start()

# 阻塞进程

for i in range(2):

ps[i].join() #没有join()函数时，主进程不需要等子进程结束后再退出，可直接退出

print("主进程终止")

if name == ‘main’:
main()

执行结果：
主进程执行中>>> pid=8604
主进程终止
子进程执行中>>> pid=3192,ppid=8604
子进程执行中>>> pid=608,ppid=8604
子进程终止>>> pid=3192
子进程终止>>> pid=608