【已解答】求助宝塔的python项目运行后CPU耗费严重

1. #!/usr/bin/env Python
   
2. # coding=utf-8
   
3. import socket  # 导入 socket 模块
   
4. import struct
   
5. from threading import Thread
   
6. import time
   
7. import ast
   
8. import user
   
9. import company
   
10. import crew
    
11. import pymysql
    
12. import equipment
    
13. import overhaul
    
14. import config
    
15. import common
    
16. import os
    
17. import takejudge
    
18. from base import Protocol
    
19. import json
    
20. import metal.standingbook as standingbook
    
21. import metal.MetallicMaterials as metallic
    
22. import metal.MetalPlan as MetalPlan
    
23. import filemanage
    
24. 
    
25. 
    
26. 
    
27. 
    
28. ADDRESS = ('', 7891)  # 绑定地址
    
29. FILEADDRESS = ('', 7890)  # 绑定服务器接收文件的IP地址
    
30. g_socket_server = None  # 负责监听的socket
    
31. file_socket_server = None  # 负责监听file的socket
    
32. g_conn_pool = []  # 连接池
    
33. gfile_conn_pool = []  # 连接池
    
34. # BASE_DIR = os.path.dirname(os.path.abspath(__file__))
    
35. BASE_DIR = "/data/"
    
36. ##print('basedir:',BASE_DIR)
    
37. 
    
38. '''
    
39. 接收数据格式：
    
40. 判断方式+
    
41. 
    
42. '''
    
43. 
    
44. def init():
    
45.     """
    
46.     初始化服务端
    
47.     """
    
48.     global g_socket_server,file_socket_server
    
49.     g_socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 创建 socket 对象
    
50.     g_socket_server.bind(ADDRESS)
    
51.     g_socket_server.listen(128)  # 最大等待数（有很多人理解为最大连接数，其实是错误的）
    
52.     print("服务端已启动，等待客户端连接...")
    
53.     '''接收文件的服务器'''
    
54.     file_socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 创建 socket 对象
    
55.     file_socket_server.bind(FILEADDRESS)
    
56.     file_socket_server.listen(128)  # 最大等待数（有很多人理解为最大连接数，其实是错误的）
    
57.     ##print("服务端已启动，等待客户端连接...")
    
58. 
    
59. 
    
60. def accept_client():
    
61.     """
    
62.     接收新连接
    
63.     """
    
64.     while True:
    
65.         client, _ = g_socket_server.accept()  # 阻塞，等待客户端连接
    
66.         ##print(client)
    
67.         # 加入连接池
    
68.         g_conn_pool.append(client)
    
69. 
    
70.         # 给每个客户端创建一个独立的线程进行管理
    
71.         thread = Thread(target=message_handle, args=(client,))
    
72.         # 设置成守护线程
    
73.         thread.setDaemon(True)
    
74.         thread.start()
    
75. 
    
76. def accept_file_client():
    
77.     """
    
78.     接收新连接
    
79.     """
    
80.     while True:
    
81.         clientfile, _ = file_socket_server.accept()  # 阻塞，等待客户端连接
    
82.         ##print(client)
    
83.         # 加入连接池
    
84. 
    
85.         # 给每个客户端创建一个独立的线程进行管理
    
86.         thread = Thread(target=file_handle, args=(clientfile,))
    
87.         # 设置成守护线程
    
88.         thread.setDaemon(True)
    
89.         thread.start()
    
90. def pck_handler(client,recvtext):
    
91.     """
    
92.     解析数据包
    
93.     """
    
94. 
    
95.     # 正常数据包定义
    
96.     ##print(typesendtext',type(recvtext),recvtext)
    
97.     print("第一次",recvtext)
    
98.     b2 = recvtext.decode('utf8')
    
99.     print(recvtext.decode("utf-8").encode("GBK") )
    
100. 
     
101.     ##print("特殊字符转义前：!",b2)
     
102.     # body = pymysql.escape_string(b2)
     
103.     ##print("特殊字符转义后：!",body)
     
104.     user_dict = ast.literal_eval(b2)
     
105. 
     
106.     print('user_dist',user_dict)
     
107.     '''对内含特殊字符的内容进行批量转义开始'''
     
108.     for n in user_dict:
     
109.         if type(user_dict[n]) == str:
     
110.             ##print(n, pymysql.escape_string(user_dict[n]))
     
111.             user_dict[n] = pymysql.escape_string(user_dict[n])
     
112.         else:
     
113.             pass
     
114.             ##print(n, 'is not str')
     
115.     '''对内含特殊字符的内容进行批量转义结束'''
     
116.     ##print(user_dict['juage'])
     
117.     print(user_dict)
     
118. 
     
119.     # myddd =  str(sendtext, encoding = "utf8")
     
120.     ##print(myddd,type(myddd))
     
121. 
     
122.     if user_dict['juage'] == 'common':
     
123.         ##print(当前在线人数：',len(g_conn_pool))
     
124.         if user_dict['name'] == 'getmysqltable':
     
125.             #'获得表结构')
     
126.             result = common.getmysqltable(user_dict)
     
127.             #('result',result)
     
128.         elif user_dict['name'] == 'save_tablewidgetdata':
     
129.             ##print(获取指定表内的1条数据')
     
130.             result = common.save_tablewidgetdata(user_dict)
     
131.             ##print(result',result)
     
132. 
     
133.     elif user_dict['juage'] == 'user':
     
134.         ##print(juage1')
     
135.         if user_dict['name'] == 'register':
     
136.             ##print(juage2')
     
137.             result = user.UserRegister(user_dict)
     
138.             ##print(result',result)
     
139.         elif user_dict['name'] == 'createsonuser':
     
140.             ##print(checklogin')
     
141.             result = user.createsonuser(user_dict)
     
142. 
     
143.     send_text(client,str(result))
     
144. 
     
145. def send_text(client,senddata):
     
146.     ##print('准备发送：',client,"\n",senddata)
     
147.     ver = 1
     
148. 
     
149.     #
     
150.     try:
     
151.         body = json.dumps(senddata)#方法1
     
152.     except:
     
153.         body = str(senddata)  # 方法2，强制
     
154.     ##print(body,type(body))
     
155.     ##print(len(body))
     
156.     ##print(body.__len__())
     
157.     cmd = 101
     
158.     header = [ver, body.__len__(), cmd]
     
159.     ##print('header',header)
     
160.     headPack = struct.pack("!3I", *header)
     
161.     ##print('headPack',headPack)
     
162. 
     
163.     sendData1 = headPack + body.encode()
     
164.     ##print('sendData1',sendData1)
     
165.     client.send(sendData1)
     
166.     client.close()
     
167.     # # 删除连接
     
168.     g_conn_pool.remove(client)
     
169. 
     
170. 
     
171. def dataHandle(client,headPack, bytes):
     
172.     # 切割数据包
     
173.     while True:
     
174.         # 读取包长度
     
175.         length_pck = int.from_bytes(bytes[:4], byteorder='little')
     
176.         ##print(包长度', length_pck)
     
177.         # 截取封包
     
178.         pck = bytes[4:4 + length_pck]
     
179.         # 删除已经读取的字节
     
180.         bytes = bytes[4 + length_pck:]
     
181.         ##print(pck, bytes, '把封包交给处理函数')
     
182. 
     
183.         # 把封包交给处理函数
     
184.         pck_handler(pck, client)
     
185.         ##print(2')
     
186.         # 如果bytes没数据了，就跳出循环
     
187.         if len(bytes) == 0:
     
188.             break
     
189.         ##print("客户端消息：", bytes.decode(encoding="utf8"))
     
190. 
     
191. 
     
192. def message_handle(client):#用于接收服务器发过来的分包数据
     
193.     """
     
194.     消息处理
     
195.     """
     
196.     # FIFO消息队列
     
197.     ##print("FIFO消息队列")
     
198.     dataBuffer = bytes()
     
199. 
     
200.     ##print("databuffer:",type(dataBuffer))
     
201.     # 自定义消息头的长度
     
202.     headerSize = 12
     
203. 
     
204.     # 定义数据包的个数
     
205.     sn = 0
     
206.     # client.sendall("lianjiechenggong!".encode(encoding='utf-8'))
     
207.     while True:
     
208.         try:
     
209.             data = client.recv(1024)
     
210.             len(data)
     
211. 
     
212.             if data:
     
213.                 # 把数据存入缓冲区，类似于push数据
     
214.                 dataBuffer += data
     
215.                 while True:
     
216.                     if len(dataBuffer) < headerSize:
     
217.                         ##print("数据包（%s Byte）小于消息头部长度，跳出小循环" % len(dataBuffer))
     
218.                         break
     
219. 
     
220.                     # 读取包头
     
221.                     # struct中:!代表Network order，3I代表3个unsigned int数据
     
222.                     headPack = struct.unpack('!3I', dataBuffer[:headerSize])
     
223.                     bodySize = headPack[1]
     
224. 
     
225.                     # 分包情况处理，跳出函数继续接收数据
     
226.                     if len(dataBuffer) < headerSize + bodySize:
     
227.                         ##print("数据包（%s Byte）不完整（总共%s Byte），跳出小循环" % (len(dataBuffer), headerSize + bodySize))
     
228.                         break
     
229. 
     
230.                     # 读取消息正文的内容
     
231.                     body = dataBuffer[headerSize:headerSize + bodySize]
     
232. 
     
233.                     # 数据处理
     
234.                     ##print("接收到的完整信息：!",body)
     
235.                     ##print("接收到的完整type：!",type(body))
     
236. 
     
237.                     # body = pymysql.escape_string(body)
     
238.                     ##print("特殊字符转义后：!",body)
     
239. 
     
240.                     pck_handler(client,body)
     
241. 
     
242.                     # 数据出列
     
243.                     dataBuffer = dataBuffer[headerSize + bodySize:]  # 获取下一个数据包，类似于把数据pop出
     
244. 
     
245. 
     
246.         except Exception as e:  # 意外掉线
     
247.             ##print("---------------------------")
     
248.             ##print("客户端断开了。" )
     
249.             # client.close()
     
250.             # 删除连接
     
251.             # g_conn_pool.remove(client)
     
252. 
     
253. 
     
254.             break
     
255. 
     
256. 
     
257. def file_handle(fileclient):#用于接收服务器发过来的文件分包数据
     
258.     """
     
259.     上传文件处理
     
260.     """
     
261.     while True:
     
262.         data = ''
     
263.         data = fileclient.recv(1024)       #开始接收
     
264.         ##print(data)
     
265.         ##print(str(data,'utf8'))
     
266.         file_size,savepath,newname = str(data,'utf8').split('|')
     
267.         # path = os.path.join(BASE_DIR,'yuan',filename)
     
268.         # 判断文件夹是否存在，不存在，就创建
     
269.         path = os.path.join(BASE_DIR,savepath)
     
270.         if os.path.exists(path) == False:  #
     
271.             os.makedirs(path)
     
272. 
     
273.         path = os.path.join(BASE_DIR, savepath, newname)
     
274.         ##print(path)
     
275.         file_size = int(file_size)
     
276.         ##print(file_size,savepath,newname)
     
277.         f = open(path,'ab')
     
278.         has_receive = 0
     
279.         while has_receive != file_size:
     
280.             data = fileclient.recv(1024)
     
281.             f.write(data)
     
282.             has_receive += len(data)
     
283.             ##print('接收数据',has_receive,file_size)
     
284.         ##print('接收数据完成', has_receive, file_size)
     
285.         f.close()
     
286.         break
     
287.     ##print('关闭当前连接')
     
288.     fileclient.close()
     
289. 
     
290. 
     
291. if __name__ == '__main__':
     
292.     init()
     
293.     # 新开一个线程，用于接收新连接
     
294.     thread = Thread(target=accept_client)
     
295.     thread.setDaemon(True)
     
296.     thread.start()
     
297.     threadfile = Thread(target=accept_file_client)
     
298.     threadfile.setDaemon(True)
     
299.     threadfile.start()
     
300.     config.mysql
     
301.     while True:
     
302.         
     
303.         if len(g_conn_pool)==0:
     
304.             time.sleep(5)
     
305.             
     
306. 
     
307.         for i in g_conn_pool:
     
308.             ##print(i)
     
309. 
     
310.             time.sleep(5)
     
311. 
     

复制代码

求助：python在宝塔管理项目运行时CPU占用严重。
以前在windows系统下运行挺好，现在将python程序通过centos的宝塔面板python管理项目运行，CPU占用严重。python版本：3.7.8
框架：python
启动方式：python

您好，cpu占用高时，ssh内执行以下命令排查分析

1. yum -y install htop && htop

复制代码

如果确定是这个项目占用，建议脚本再细品下