进程的基础知识

1 > 代码创建进程

   创建进程的方式有两种，第一种就是用鼠标双击桌面一个应用图标，第二种就是利用代码创建进行。下面将对代码创建进程做详细的说明。
   在不同的操作系统下面创建进程的要求不一样
   在windows中创建进程是以导入模块的方式进行，所有说创建进程的代码必须写在__main__ 子代码中，否则程序运行会直接报错，因为他会在无限的创建进程。
   在Linux和mac中创建进程直接拷贝一份源代码然后执行，不需要写在__main__ 子代码中。操作代码如下：

			'''第一种用代码创建进程的方式 '''
			
from multiprocessing impor Process


def task(name):
	print('%s is running' % name)
	time.sleep(3)
	print('%s is over' % name)

if __name__ == '__main__':
	p = Process(target=task, args=('bob',))        # 创建一个进程对象
	p.start()     								   # 告诉操作系统创建一个新的进程
	print('主进程')

			'''第二种用代码创建进程的方式 (用类创建)'''
from multiprocessing import Process
import time

class MyProcess(Process):
	def __init__(self, username):
		self.username = username
		super().__init__()
	def run(self):
		print('你好啊 程序开始了', self.username)
		time.sleep(3)
		print('拜拜 程序结束了', self.username)
if __name__ == '__main__':
	p = MyProcess('tony')
	p.start()
	print('主进程')
	

2 > 进程实现并发

   编写一个服务端可以和多个客户端实现交互的功能。
   实现思路就是，将与客户端通信的服务端代码封装成一个函数，之后每来一个客户端就创建一个进程专门做交互。具体代码如下：

						''' 服务端 '''

import socket
from multiprocessing import Process

server = socket.socket()
server.bind('127.0.0.1', 8080)
server.listen(5)

# 将服务客户端的代码封装成函数（通信代码）
def talk(sock):
	while True:
		data = sock.recv(1024)
		print(data.decode('utf8'))
		sock.send(data.upper())
if __name__ == '__main__':
	while True:
		sock, addr = server.accept()
		p = Process(target=talk, args=(sock,))
		p.start()						# 创建进程

						''' 客户端 '''
import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
	client.send(b'hello big baby')
	data = client.recv(1024)
	print(data.decode('utf8'))
	

						''' 客户端1 '''
import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
	client.send(b'hello big baby')
	data = client.recv(1024)
	print(data.decode('utf8'))
	

3 > join方法

   join方法的作用就是可以让主进程代码等待子进程代码运行完毕之后再执行，

3.1 > 简单使用方法

   代码如下：

from multiprocessing import Process
import time


def task(name):
    print(f'{name} is running')
    time.sleep(6)
    print(f'{name} is over')


if __name__ == '__main__':
    p = Process(target=task, args=('bob',))
    p.start()  # 创建一个进程
    p.join()  # 等待子代码运行结束之后再往下执行 主进程
    print('主进程运行')

3.2 > join使用方法

   我们将上述代码修改，计算多个子程序代码运行时间之和，代码如下：

from multiprocessing import Process
import time


def task(name, n):
    print(f'{name} is running')
    time.sleep(n)
    print(f'{name} is over')


if __name__ == '__main__':
    p1 = Process(target=task, args=('bob', 1))
    p2 = Process(target=task, args=('kevin', 2))
    p3 = Process(target=task, args=('jason', 3))
    start_time = time.time()
    p1.start()  # 创建一个进程
    p2.start()  # 创建一个进程
    p3.start()  # 创建一个进程
    p1.join()  # 等待子代码运行结束之后再往下执行 主进程
    p2.join()  # 等待子代码运行结束之后再往下执行 主进程
    p3.join()  # 等待子代码运行结束之后再往下执行 主进程
    '''
    若是一个start和一个join相互交替的情况 代码运行总耗时就是各个任务耗时的总和
    '''
    end_time = time.time() - start_time
    print('主进程运行', f'总耗时 ：{end_time}')

4 > 进程间数据隔离

   内存可以看成是有很多个小隔间组成的 彼此不干扰，实现代码如下:

from multiprocessing import Process

money = 999

def task():
	global money  # 局部修改全局不可变类型
	money = 666

if __name__ == '__main__':
	p = Process(taeget=task)
	p.start()
	p.join()
	print(money)
'''
 这里在子进程中写了一个局部修改全局的不可变类型的方法
但是全局名称空间当中的money还是没有改变，这就是所谓的 —— 进程间的数据隔离
'''

5 > 进程对象属性和方法

5.1 > 查看进程号

   获取进程号的用处之一就是可以通过代码的方式管理进程
   进程号的查看不同系统的方法也不一样

	windows:		tasklist
	mac: 			ps -ef

   1 > 在pycharm中也可以用代码查看进程号， 方法如下：

''' 使用current_process函数 '''

from multiprocessing import Process, current_process
print(current_process().pid)

   2 > 使用os模块

os.getpid()		# 获取当前进程的进程号
os.getppid()	# 获取当前进程的父进程号

5.2 > 杀死进程号方法

	windows				taskkill关键字
	mac/linux			kill关键字

5.3 > 杀死子进程

	terminate() 方法
	

   使用该方法就不会运行子代码了，如图：

5.4 > 判断子进程是否存活

	is_alive()
	

   该方法返回值为 True/ False,，如图所示：

6 > 僵尸进程与孤儿进程

6.1 > 僵尸进程

   即所有的子进程在运行结束之后都会变成该进程（死了没死透）还保留着pid和一些运行过程中的记录便于主进程查看（短时间保存）这些信息就会被主进程回收（僵尸彻底就死了）
   变成僵尸进程的情况：

	1.当主进程正常结束
	2.调用join方法

6.2 > 孤儿进程

   即当子进程还存活 父进程意外死亡的情况 子进程就变成了孤儿进程。
   子进程会被操作系统自动接管。

7 > 守护进程

   即死活全部参考守护的对象，当对象死了它也就立刻死了。代码如下：

from multiprocessing import Process
import time

def task(name):
	print(f'大内总管：{name} 正常活着')
	time.sleep(3)
	print(f'大内总管：{name}正常死了')
if __name__ == '__main__':
	p = Process(target=task, args=('赵公公',))
	p.daemon = True		# 将子进程设置为守护进程： 主进程结束 子进程立刻结束
	time.sleep(1)		# 因为电脑的进程运行太快 当主进程结束了 可能还看不出来
	p.start()
	print('主进程寿终正寝')

8 > 互斥锁（重点）

  互斥锁的作用提现就是当每逢节假日抢票手机上明明显示还有余票 但是点击购买的时候却提示已经没有票了，之后回到查询页面发现确实显示没有票了。这个时候就需要用上这个互斥锁了。我们来模拟一下抢票系统。代码如下：
   互斥锁使用代码如下：

from multiprocessing import Process, Lock
mutex = Lock()
mutex.acquire()  # 抢锁
mutex.release()  # 放锁

										''' 抢票系统 '''
import json
from multiprocessing import Process, Lock
import time
import random


# 查票
def search(name):
    with open(r'ticket_data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    print(f'{name}查询当前余票:%s' % data.get('ticket_num'))


# 买票
def buy(name):
    # 1.查票
    with open(r'ticket_data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    time.sleep(random.randint(1, 3))
    # 2.判断是否还有余票
    if data.get('ticket_num') > 0:
        data['ticket_num'] -= 1
        with open(r'ticket_data.json', 'w', encoding='utf8') as f:
            json.dump(data, f)
        print(f'{name}抢票成功')
    else:
        print(f'{name}抢票失败 没有余票了')


def run(name, mutex):
    search(name)
    # 只需要把买票环节变成串行即可
    mutex.acquire()  # 抢锁
    buy(name)
    mutex.release()  # 放锁 


# 模拟多人同时抢票
if __name__ == '__main__':
    # 互斥锁在主进程中产生一把 交给多个子进程用
    mutex = Lock()
    for i in range(1, 10):
        p = Process(target=run, args=('用户:%s' % i, mutex))
        p.start()

   这里的抢票系统有点小小的问题，这样也报出了一些运用互斥锁时需要注意的事项，问题如下：

	当多个进程操作同一份数据的时候可能会造成数据的错乱
	这时就需要加锁处理（互斥锁）
	将并发变成串行 牺牲了效率但是保证的数据的安全

	互斥锁并不能轻易使用 容易造成死锁现象
	互斥锁只在处理数据的部分加锁 不能什么地方都加 严重影响程序的效率