socket，queue

关于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。