关于socket，queue以及多线程的总结
一、socket服务器
#socketserve.py
import OpenOPC
import socket
import struct
import Queue
import json
import time
import threading
def readHuiluTags(alist,adict,opc,queueObject):
while True:
temp=opc.read(alist)
for i in range(len(temp)):
adict[temp[j][0]]=temp[j][1]
queueObject.put(adict)
block为可选参数，默认为True,如果当前队列为空且block为1，put()方法就使调用线程暂停，直到空出一个数据单元，如果block为Flase,put方法将引发Full异常,timeout为等待时间，None为一直等下去，0为不等待，正数n为等待n秒还不能存入，报异常。
serve=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建socket对象
serve.bind(('192.168.1.80',8080)) #绑定地址和端口
地址和端口以元组的形式输入，通常地址可以写为'localhost'
serve.listen(5) #让socket服务器进入监听状态
输入的参数并不代表可以连接的最大客户端数目是五个，它代表的是加入你服务器可以承载的客户端连接数量是100个，
那该服务器最大可以使5个客户端排队等待。当有第106个客户端连接进来的时候就会报错。
while True:
con,address=serve.accept() #阻塞式连接：表示服务器端运行到这里会等待，当客户端连接进来的时候，程序再继续往下运行
该方法返回的是一个元组tuple,con是返回的当前连接的客户端对象
clientId=con.recv(1024) #接收客户端发送到服务器的数据
socket服务器与客户端传递数据是以二进制的格式进行传递的，所以无论在服务器端还是在客户端，想要发送和接收的数据都需要进行转换
if cilentId='K01':
huiluNum=2
tagsNameAll=json.loads(con.recv(1024)) 因为传递过来的数据是一个字符串，所以得用json.loads进行转换
threadList=[]
giveToclient=Queue.LifoQueue(maxsize=0) 创建一个队列用于存储所有标签及对应数据的字典
LifoQueue是后入先出的队列，Queue是先入先出的队列，
maxsize这个参数表示队列里面可以存储数据的最大个数，maxsize<=0表示无限制
allTagsValue={}
temp=threading.Thread(target=函数名，args=(该函数需要的参数)
threadList.append(temp)
while True:
temp1=giveToClient.get(block=True,timeout=None) 调用队列对象的get()方法从队尾删除并返回一个项目
可选参数为block,默认为True，如果队列为空且block为True，get()就使调用线程暂停，直至有项目可用，如果队列为空且block为Flase,队列将引发Empty异常，timeout为等待时间，None为一直等下去，0为不等待，正数n为等待n秒还不能读取，报异常。
con.send(json.dumps(temp1).encode('gbk')) 发送的数据必须为二进制的
refPvDict=[]
valueList=[]
for key in refPvDict:
pvList.append(key)
for key in refPvDict.values():
valueList.append(value)
for i in range(huiluNum):
opc.write((pvList[i],valueList[i]))
con.close()
serve.close()
在进行多线程的编程中，我们需要在主线程中创建队列进行主线程和子线程的通讯，所以在子线程最好创建队列来存储数据，这样创建出来的队列的数据没有办法和主线程及其他线程共享，另外最好不要在子线程中修改主线程中队列里面的数据。子线程的优势在于，只是从主线程的队列里面的拿数据，并向主线程的队列返回数据。
另外，以共有三种模式的队列可以创建。
一是先入先出模式，queue.Queue(),即队列中的数据按顺序存储在队列中，从队列中取数据的时候也是按顺序取，取完一个就在队列里面删除取走的那个。
二是后入先出模式，queue.LifoQueue()即队列中的数据按顺序存储在队列中，从队列中取数据的时候取最后一个数据。
三是设置优先级模式，还未学习，等待补充
二、socket客户端
import socket
import struct
import json
import threading
import queue
import time
import numpy as np
#定义PIDcontrol
def PIDcontrol(queueObject,refName,pvName,adict,Kp=0.6,Ki=0.3,Kd=0,u1=0,Ee=0):
while True:
temp=queueObject.get(block=True,timeout=None)
a=Kp*temp[pvName]+Ki*u1+int(np.random.rand(1,1)[0])
e=temp[refName]-a
u=e+Ee
u1=u
Ee=Ee+e
adict[pvName]=a
return
def dividehuilu(queue,anotherlist,alist):
while True:
newdict={}
adict=queue.get(block=True,timeout=None)
for i in anotherlist:
for key in adict:
if i == key:
newdict[i]=adict[key]
print(type(adict))
temp1=[]
temp2=[]
temp3={}
temp4={}
for key in newdict:
temp1.append(key)
for value in newdict.values():
temp2.append(value)
for i in range(2):
temp3[temp1[i]]=temp2[i]
temp4[temp1[i+2]]=temp2[i+2]
print(temp1,temp2,temp3,temp4)
alist[0].put(temp3)
alist[1].put(temp4)
def readLoop(socketObject,queueObject):
while True:
temp=json.loads(socketObject.recv(1024).decode('gbk'))
queueObject.put(temp)
#配置socket客户端
clientK01=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
clientK01.connect(('192.168.1.80',8080))
#客户端的任务
#任务一：提供工序名字
clientId='K01'.encode('gbk')
#任务二：告诉服务器我需要的相应的标签的值
tagsName=['[L01]huilu1_sp','[L01]huilu1_ref','[L01]huilu2_sp','[L01]huilu2_ref']
#任务三：说明该工序有几个回路
huiluNum=2
huilu1=['[L01]huilu1_sp','[L01]huilu1_ref']
huilu2=['[L01]huilu2_sp','[L01]huilu2_ref']
valuesAll=queue.LifoQueue()
threadList=[]
queueList=[]
refPvDict={}
clientK01.send(clientId)
#发送需要的标签名给服务器
clientK01.send(json.dumps(tagsName).encode('gbk'))
#接收服务器发来的字典数据：标签名为键，标签值为值，这个得循环的读，因为有更新
readValueLoop=threading.Thread(target=readLoop,args=(clientK01,valuesAll))
threadList.append(readValueLoop)
readValueLoop.start()
#tagsValueDict=clientK01.recv(1024)
#tagsValueDict=json.loads(tagsValueDict)
#print(tagsValueDict)
for i in range(huiluNum):
huiluQueue=queue.LifoQueue(maxsize=0)
queueList.append(huiluQueue)
readHuiluQueue=threading.Thread(target=dividehuilu,args=(valuesAll,tagsName,queueList))
threadList.append(readHuiluQueue)
readHuiluQueue.start()
PIDhuilu1=threading.Thread(target=PIDcontrol,args=(queueList[0],'[L01]huilu1_sp','[L01]huilu1_ref',refPvDict))
threadList.append(PIDhuilu1)
PIDhuilu1.start()
PIDhuilu2=threading.Thread(target=PIDcontrol,args=(queueList[1],'[L01]huilu2_sp','[L01]huilu2_ref',refPvDict))
threadList.append(PIDhuilu2)
PIDhuilu2.start()
for i in threadList:
i.join(2)
#join函数表示每个线程执行两秒后再进行主程序的执行
while True:
time.sleep(5)
#print(refPvDict)
clientK01.send(json.dumps(refPvDict).encode('gbk'))
clientK01.close()
注意：用socket一次只能和一个客户端进行交互，其余的客户端要交互需要排队等候，等前面的断开。所以我们想连接多个客户端就要用socketserver。