进程与线程（没整理好）

基础知识

• 并发（一人一段时间做多事）（充分利用资源，提高CPU的利用率）
  • 在操作系统中，并发是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行。
• 并行（多人同时做多事）
  • 当系统有一个以上CPU时,则程序的操作有可能非并发。当一个CPU执行一个程序时，另一个CPU可以执行另一个程序，两个程序互不抢占CPU资源，可以同时进行，这种方式我们称之为并行。如下图：
    
• 计算机程序只是存储在磁盘上的可执行二进制（或其他类型）文件。只有把它们加载到内存中并被操作系统调用，才拥有其生命周期。进程则是一个执行中的程序。
• 每个进程都拥有自己的地址空间，内存，数据栈以及其他用于跟踪执行的辅助数据。
• 操作系统直接管理进程，操作系统管理其上所有进程的执行，并为这些进程合理分配时间。
  案例：
  #模仿耗时函数
  import time
  #import random
  def func():
  #模仿耗时
  time.sleep(3)
  if name==“main”:
  s_time = time.time()#获取开始时间
  func()
  func()
  e_time = time.time()#获取结束时间
  print(“耗时%s秒”%(e_time-s_time))

多进程

#多进程提高运行效率
import time
from multiprocessing import Process
def func():
#模仿耗时三秒
print(1)
time.sleep(3)
if name==“main”:
s_time = time.time()
#创建一个进程func是要执行的函数
p1 = Process(target=func)
#启动这个进程
p1.start()
func()
e_time = time.time()
print(e_time-s_time) #1,1,3.005776882171631
多进程使用流程

多进程
from multiprocessing import Process
import time
def func1(a,b):
time.sleep(2)
print(res)
res = a + b

if name==“main”:
s_time = time.time()
func1(1+1)
p1 = Process(target=func1,args=(2,2))
#p1 = Process(func1,args=(2,2))
p1.start() #启动进程
e_time = time.time #2,2.00451…,4
- 进程数量不多于 CPU核心数量！
- 现在运行的程序都是轮询调度产生的并行假象。
- 但是在Python程序，用户层面的确获得了并行！

多线程

- 线程，有时被称为轻量进程(Lightweight Process，LWP），是程序执行流的最小单元。 多任务可以由多进程完成，也可以有一个进程内的多线程完成。我们前面讲过进程是由若干线程组成的，一个进程至少有一个线程。
- 当其他线程运行时，它可以被抢占（中断）和临时挂起（也成为睡眠） — 让步。
- 线程的轮询调度机制类似于进程的轮询调度。只不过这个调度不是由操作系统来负责，而是由Python解释器来负责。
案例：

#多线程执行耗时任务
import time
from threading import Thread
def func():
print(“任务开始了”)
time.sleep(2)
if name==“main”:
s_time = time.time()
t1 = Thread(target=func)
t1.start()
func()
e_time = time.time()
print(e_time-s_time) #2.00286…
多线程使用流程

- python中多线程只能并发，不能并行

Gil锁

- Python在设计的时候，还没有多核处理器的概念，因此，为了设计方便与线程安全，直接设计了一个锁。这个锁要求，任何进程中，一次只能有一个线程在执行.因此，并不能为多个线程分配多个CPU。所以Python中的线程只能实现并发，而不能实现真正的并行。但是Python3中的GIL锁有一个很棒的设计，在遇到任何IO阻塞（不是耗时）的时候，会自动切换线程。

用多进程，多线程写并发服务器

并发服务器(多进程)

#也适合在Windows下运行
import multiprocessing
import socket
import os
os.getpid() #当前进程id
def task(sock):#子进程中的任务逻辑
print(“我是进程%s”%os.getpid())
while True:
recv_data = sock.recv(1024)
if recv_data:
print(recv_data.decode(“utf-8”))
sock.send(recv_data)
else:
break
sock.close()
if name==“main”":
server = socket.socket()
server.bind(("",6969))
server.listen(20)
while True:
conn,addr = server.accept()
#每当有一个连接进来之后，就生成一个新的进程去处理
process = multiprocessing.Process(
target=task,
args=(conn,)
)
process.start()

并发服务器（多线程）

from threading import Thread
import socket
import os #当前进程id
os.getpid()
def task(sock): #子线程中的任务逻辑
print(“我是线程%s”%os.getpid())
while True:
recv_data = sock.recv(1024)
if recv_data:
print(recv_data.decode(“utf-8”))
sock.send(recv_data)
else:
break
sock.close()
if name==“main”:
server = socket.socket()
server.bind(("",8686))
server.listen(20)
while True:
conn,addr = server.accept()
#每当有一个连接进来之后，就生成一个新的线程去处理
thread = Thread(
target=task,
args=(conn,)
)
thread.start()