python下的线程 进程,以及如何实现并发服务器

时间:2021-03-15 18:33:54

在一个CPU(一核)的电脑上,

程序的运行是并发运行的,调度的算法叫时间片轮转法,也叫轮询法

在多CPU(多核)的电脑上,一个CPU跑一个程序,刚程序运行数量小于核心数时,程序是并行的

并发:看上去一起执行,同时在发生

python下的线程 进程,以及如何实现并发服务器

 

 

并行:真正的一起执行,同时在进行

python下的线程 进程,以及如何实现并发服务器

 进程的概念:

  计算机程序是存储在磁盘上的可执行二进制(或者其他类型)文件

    只有当他们被加载到内存中,并被操作系统调用的时候,他们才会拥有自己的生命周期

  进程则表示一个正在执行的程序

    每个程序都拥有自己的地址空间,内存,数据栈以及其他用于跟踪执行的辅助资料

  操作系统负责其上的所有进程的执行

    操作系统会为这些进程合理的分配执行时间

线程的概念:

  线程被称作轻量级进程

     与进程类似,不过他们是在不同的进程下执行的。并且他们会共享相同的上下文

  当其他线程执行时,他可以被抢占(中断),和临时挂起(睡眠)---------让步

    线程的轮询调度机制类似于进程的轮询调度。只不过这个调度不是由操作系统来负责的,而是由python解释器来负责

 

 

CPU,进程,线程之间的调度关系

CPU——>进程——>线程

 python下的线程 进程,以及如何实现并发服务器

 

 

利用进程和线程,实现并发服务器

线程:(GIL全局解释器锁:遇到阻塞就切换)

from socket import *
import threading
server = socket()
server.bind(('', 9999))
server.listen(1000)

def func(conn):
    while True:
        recv_date = conn.recv(1024)
        if recv_date:
            print(recv_date.decode('utf8'))
            conn.send(recv_date)
        else:
            conn.close()
            break

while True:
    conn, addr = server.accept()
    w = threading.Thread(target=func, args=(conn, )) # 开启一个子线程
    w.start()

进程:

import multiprocessing
from socket import *
server = socket()
server.bind(('', 9999))
server.listen(10)

def func(conn):
    while True:
        recv_date = conn.recv(1024)
        if recv_date:
            print(recv_date.decode('utf8'))
            conn.send(recv_date)
        else:
            conn.close()
            break

while True:
    conn, addr = server.accept()
    w = multiprocessing.Process(target=func, args=(conn, )) # 开启一个子进程
    w.start()

补充:

  等待结束:.join()  

     我们调用的子进程或者子线程,阻塞等待,直到进程或者线程结束

from threading import Thread
from time import sleep, ctime

def func():
    sleep(5)
    print('子进程结束了')
    print(ctime())

print(ctime())
t = Thread(target=func)
t.start()
t.join()    # 等待子线程执行完毕才会继续往下执行
sleep(5)
print('主进程结束')
print(ctime())

程序会执行10秒才会结束

如果没有t.join()
子线程和主进程同时执行,用时5秒

 

  查看当前进程和当前线程   multiprocessing.current_process() / multiprocessing.current_thread()

    还是之前的代码

 1 import multiprocessing
 2 from threading import Thread, current_thread
 3 from time import sleep,ctime
 4 
 5 def func(): 7     print(multiprocessing.current_thread())
 8     print('子进程结束了')
 9     print(ctime())
10 12 t = Thread(target=func)
13 t.start()
14 t.join()
15 print(multiprocessing.current_process())
16 print('主进程结束')18 
19 
20 <Thread(Thread-1, started -1223357632)>
21 子进程结束了
23 <_MainProcess(MainProcess, started)>
24 主进程结束
26 
27 Process finished with exit code 0

 

  终止进程  进程/线程.terminate()

    强制终止子进程/线程,不管进程/线程有没有执行完毕,直接结束

 

  进程/线程的标志    进程print(multiprocessing.process().pid)

           线程print(threading..current_thread().ident)

 1 import threading
 2 from time import sleep,ctime
 3 import multiprocessing
 4 
 5 def func():
 6     # sleep(5)
 7     print(threading.current_thread())
 8     print(threading.current_thread().ident)
 9     print('子进程结束了')
10     print(ctime())
11 
12 print(ctime())
13 t = threading.Thread(target=func)
14 t.start()
15 t.join()
16 print(multiprocessing.current_process())
17 print(multiprocessing.current_process().pid)
18 print('主进程结束')
19 print(ctime())
20 
21 
22 <Thread(Thread-1, started -1223124160)>
23 -1223124160
24 子进程结束了
25 Sat Aug 18 14:53:22 2018
26 <_MainProcess(MainProcess, started)>
27 3885
28 主进程结束
29 Sat Aug 18 14:53:22 2018
30 
31 Process finished with exit code 0

 

    查看进程/线程名      实例化的时候输入:m = multiprocessing.Process(target=func, name = 'xxxx')

             或者实例化的声明  m.name = 'xxxx'

from multiprocessing import Process

def func():
    pass

m = Process(target=func, name='pywjh')
'''
或者m = Process(target=func)
     m.name = 'pywjh'
'''

print('1>>', m)
m.start()
print('2>>', m)
m.join()
print('3>>', m)


1>> <Process(pywjh, initial)>      # 最初
2>> <Process(pywjh, started)>    # 开始
3>> <Process(pywjh, stopped)>   # 结束

Process finished with exit code 0

 

  查看进程/线程是否还在运行    print(m.is_alive(),m)

 1 from multiprocessing import Process
 2 
 3 def func():
 4     pass
 5 
 6 m = Process(target=func, name='pywjh')
 7 '''
 8 或者m = Process(target=func)
 9      m.name = 'pywjh'
10 '''
11 
12 print('1>>', m.is_alive(), m)
13 m.start()
14 print('2>>', m.is_alive(), m)
15 m.join()
16 print('3>>', m.is_alive(), m)
17 
18 
19 
20 1>> False <Process(pywjh, initial)>
21 2>> True <Process(pywjh, started)>    # 只有start才算活着
22 3>> False <Process(pywjh, stopped)>
23 
24 Process finished with exit code 0

 

    守护进程/线程    daemon = True    p = Process(target=func, daemon=True)

      把这个进程设置为守护进程随主线程关闭而关闭