网络编程多线程/socketserver模块/threading.local

server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
server.bind(("192.168.12.193",8085))
server.listen(5)
print("starting")
def talk(conn,addr):
"""
接收数据发送数据函数
:param conn:
:param addr:
:return:
"""
while True:
try:
data=conn.recv(1024)
if not data:break
conn.send(data.upper())
except ConnectionResetError:
break
conn.close()
while True:
conn,addr=server.accept()
t=Thread(target=talk,args=(conn,addr))
t.start()
server.close()

客户端:

import socket
custom=socket.socket()
custom.connect(("127.0.0.1",8080))
while True:
msg=input(" ").strip()
if not msg:
continue
custom.send(msg.encode("utf-8"))
data=custom.recv(1024)
print(data.decode("utf-8"))
custom.close()

守护进程和守护线程

守护进程:当主进程运行完后,不管子进程运没运行完,子进程都将立即被终止.不管有没有其他的子进程

应用:如果有多个Python项目都在运行,我们如果写一个脚本来监控这些项目,可以用守护进程的方式,zaxbit

不用守护进程的情况下:

from multiprocessing import Process
import os,time
def task():
time.sleep(2)
print("这是进程%s"%1)
if __name__ == '__main__':
t=Process(target=task)
t.start()
print('主进程')

结果:

主进程
这是进程1

使用守护进程后:

from multiprocessing import Process
import os,time
def task():
time.sleep(2)
print("这是进程%s"%1)
if __name__ == '__main__':
t=Process(target=task)
t.daemon=True #注意守护进程必须在p.start()之前设置,开启守护进程不能再开启子进程
t.start()
print('主进程')

结果:

主进程

注意:

注意守护进程必须在p.start()之前设置,
开启的守护进程不能再开启守护进程的子进程 因为进程之间是相互独立的.如果开启再开启子进程后,当守护进程停止后,没有人回收子进程.

守护进程死掉的时间: 当主进程代码执行完后,守护进程就会死掉

守护线程

注意:

守护线程必须在p.start()之前设置
开启的守护线程可以再开启守护进程的子进程,因为在同一个进程中,如果主线程死掉,子线程也会死掉
当主进程结束了,当还有其他线程执行时,守护线程会继续守护其他的线程.

列如:

from threading import Thread
import os,time
def task():
time.sleep(2)
print("这是线程%s"%1)
tt=Thread(target=time.time()) #开启子线程
print(time.time())
tt.start()
if __name__ == '__main__':
t=Thread(target=task)
t.daemon=True #守护进程必须在p.start()之前设置,守护进程不能开启子进程
t.start()
print('主线程')

结果:

主线程

守护线程死掉的时间:当进程內非守护线程都运行完后,进程就会死掉,守护线程才死掉.这也就是守护线程和守护进程的区别

from threading import Thread
import os,time
def task():
time.sleep(2)
print("这是线程%s"%1)
def task1():
time.sleep(3)
print("这是线程%s" % 2)
if __name__ == '__main__':
t1=Thread(target=task)
t2=Thread(target=task1)
t1.daemon=True #守护进程必须在p.start()之前设置,守护进程不能开启子进程
t1.start()
t2.start()
print('主线程)

结果:

主线程
这是线程1
这是线程2

threading.local

我们知道线程之间的数据是共享的,但是有没有一种技术可以让线程内的数据不共享.恰好python 为我们提供了threading.local可以实现该功能.

import threading
local=threading.local() #实例化一个全局对象
local.val='main-Thread' #在该线程下给local对象添加对象属性
def process_student():
print('%s (in%s)内存地址为%s'%(local.val,threading.current_thread().getName(),id(local.val)))
def process_thread(name):
local.val=name
process_student()
if __name__ == '__main__':
#开启两个子线程
t1 = threading.Thread(target=process_thread, args=('one',), name="Thread-A")
t2 = threading.Thread(target=process_thread, args=('two',), name="Thread-B")
t1.start()
t2.start()
t1.join()
t2.join()
print('主线程的值为%s,内存地址为%s'%(local.val,id(local.val)))#打印当前现成的额值

结果:

one (inThread-A)内存地址为1545252686736
two (inThread-B)内存地址为1545252717264
主线程的值为main-Thread,内存地址为1545252704688

从结果上看来,两个子线程并没有把local.val中的值覆盖,而是自己重新开辟了一块内存空间,来存放数据,这样就把线程之间的数据給隔离开来了.

作用: 用于保存和隔离线程之间的数据.

应用:

这个东西可以用在那些地方呢，比如下载，现在都是多线程下载了，就像酷狗那样，可以同时下载很多首歌曲，那么

就可以利用这个方法来保存每个下载线程的数据，比如下载进度，下载速度之类的

所以  如果你在开发多线程应用的时候  需要每个线程保存一个单独的数据供当前线程操作，可以考虑使用这个方法，简单有效

socketserver模块

优秀的博客

python共提供了两个socket模块

一个是：socket

另一个是socketserver 模块   简化了网络服务器的开发，解决了io问题。

SocketServer模块简化了编写网络服务程序的任务。同时SocketServer模块也 是Python标准库中很多服务器框架的基础。

这个模块提供了多进程和多线程的接口,但是多进程不能在Windows系统下用

服务端:

import socketserver
class MyTCPhandler(socketserver.BaseRequestHandler):
def handle(self):#重写handle方法
cOnn=self.request #这步相当于conn
addr=self.client_address #这步相当于addr
print(conn,addr)
while True:
try:
data=conn.recv(1024)
if not data:break
conn.send(data.upper())
except ConnectionResetError:
break
conn.close()
if __name__ == '__main__':
server=socketserver.ThreadingTCPServer(("127.0.0.1",8080),MyTCPhandler) #这一步就是做了,建立连接,开线程的工作
注意在Windows系统上不能用socketserver来开线程,在其他系统上可以用socketserver.ForkingTCPServer(("127.0.0.1",8080),MyTCPhandler)来创建

server.allow_reuse_address=True #是否允许地址的重复利用,默认为false
server.serve_forever()#一直运行

客户端:

import socket
client=socket.socket()
client.connect(('127.0.0.1',8080))
while True:
date = input(' ')
client.send(date.encode())
data = client.recv(1024)
print(' ', data.decode())
client.close()