在Python中直接执行耗时函数

import datetime
import time

print('mainprocess start time: ',datetime.datetime.now())

def func():
   print('subprocess start time: ',datetime.datetime.now())
   time.sleep(5)
   print('subprocess end time: ',datetime.datetime.now())


func()

time.sleep(5)
print('mainprocess end time: ',datetime.datetime.now())

mainprocess start time:  2018-07-04 17:57:13.628758
subprocess start time:  2018-07-04 17:57:13.629360
subprocess end time:  2018-07-04 17:57:18.635484
mainprocess end time:  2018-07-04 17:57:23.668106

10s

多进程实现并发

在Python中使用进程来分担耗时任务

import multiprocessing
import datetime
import time

print('mainprocess start time: ',datetime.datetime.now())

def func():
   print('subprocess start time: ',datetime.datetime.now())
   time.sleep(5)
   print('subprocess end time: ',datetime.datetime.now())


pro = multiprocessing.Process(target=func)
pro.start()

time.sleep(5)
print('mainprocess end time: ',datetime.datetime.now())

5s

mainprocess start time:  2018-07-04 17:58:37.564671
subprocess start time:  2018-07-04 17:58:37.575270
mainprocess end time:  2018-07-04 17:58:43.884599
subprocess end time:  2018-07-04 17:58:43.885237

多线程实现并发

import threading
import datetime
import time

print('mainthread start time: ',datetime.datetime.now())

def func():
   print('subthread start time: ',datetime.datetime.now())
   time.sleep(5) # 模拟阻塞任务
   print('subthread end time: ',datetime.datetime.now())


pro = threading.Thread(target=func) # 创建线程
pro.start() # 运行线程

time.sleep(5)
print('mainthread end time: ',datetime.datetime.now())

5s

mainthread start time:  2018-07-04 18:07:04.236883
subthread start time:  2018-07-04 18:07:04.237946
mainthread end time:  2018-07-04 18:07:09.242650
subthread end time:  2018-07-04 18:07:09.243073

GIL锁

Python在设计的时候，还没有多核处理器的概念。
因此，为了设计方便与线程安全，直接设计了一个锁。
这个锁要求，任何python进程中，一次只能有一个线程在执行。
、
因此，并不能为多个线程分配多个CPU。
所以Python中的线程只能实现并发，
而不能实现真正的并行。

但是Python3中的GIL锁有一个很棒的设计，
在遇到阻塞（不是耗时）的时候，会自动切换线程。


遇到阻塞就自动切换。
因此我们可以利用这种机制来
有效的避开阻塞 ~
充分利用CPU

使用多进程与多线程来实现并发服务器

关键点一： 多进程是并行执行，
          相当于分别独立得处理各个请求。

关键点二： 多线程，虽然不能并行运行，
          但是可以通过避开阻塞切换线程
          来实现并发的效果，并且不浪费U

多线程

import threading
import socket

server = socket.socket()
server.bind(('0.0.0.0',8888))
server.listen(5)


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


while True:
   conn,addr = server.accept()
   # 每次生成一个对等连接套接字 就生成一个线程 并交由这个线程去服务
   thread = threading.Thread(target=func,args=(conn,))
   thread.start()

import socket
client = socket.socket()
client.connect(('127.0.0.1',8888))

while True:
   data = input('请输入')
   client.send(data.encode())

   if data:
      data = client.recv(1024)
      print(data.decode())
   else:
      client.close()
      break

多进程

import multiprocessing
import socket

server = socket.socket()
server.bind(('0.0.0.0',8899))
server.listen(5)


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


while True:
   conn,addr = server.accept()
   process = multiprocessing.Process(target=func,args=(conn,))
   process.start()

import socket
client = socket.socket()
client.connect(('127.0.0.1',8899))

while True:
   data = input('请输入')
   client.send(data.encode())

   if data:
      data = client.recv(1024)
      print(data.decode())
   else:
      client.close()
      break

windows 下的python3解释器

进程

扫描二维码关注公众号，回复： 3106658 查看本文章

import multiprocessing
import socket


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


if __name__ == '__main__':

   server = socket.socket()
   server.bind(('0.0.0.0', 8898))
   server.listen(5)

   while True:
      conn,addr = server.accept()
      process = multiprocessing.Process(target=func,args=(conn,))
      process.start()

import socket
client = socket.socket()
client.connect(('127.0.0.1',8898))

while True:
   data = input('请输入')

   if data:
      client.send(data.encode())
      data1 = client.recv(1024)
      print(data1.decode())
   else:
      break
client.close()

线程

import threading
import socket



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


if __name__ == '__main__':

   server = socket.socket()
   server.bind(('0.0.0.0', 8889))
   server.listen(5)

   while True:
      conn,addr = server.accept()
      thread = threading.Thread(target=func,args=(conn,))
      thread.start()

import socket
client = socket.socket()
client.connect(('127.0.0.1',8889))

while True:
   data = input('请输入')

   if data:
      client.send(data.encode())
      data1 = client.recv(1024)
      print(data1.decode())
   else:
      break
client.close()