Как заставить while l oop выполняться один раз, а затем запускаться параллельно с функцией в Python?

Question

Ниже мой код, в котором my while l oop получает блоки данных с сервера и помещает их в буфер FIFO, после чего вызывается функция для выполнения вычислений с блоками данных из буфера и записи результата в файл. , параллельно пока l oop непрерывно получает блоки данных от сервера. Таким образом, while l oop продолжает получать блоки данных и помещает их в буфер, а функция выполняется параллельно, чтобы продолжать выполнять вычисления с блоками данных и записывать в файл.

import socket
import turtle
#import timeit
import queue
from threading import Thread
from tkinter import *

class GUI:

    def __init__(self, master):
        self.master = master
        master.title("Collision Detection")
    
        self.buff_data = queue.Queue()
    
        self.input_label = Label(root, text = "Input all the gratings set straight wavelength values in nm")
        self.input_label.grid(row = 0)
    
        self.core_string = "Core "
        self.entries = []

        self.label_col_inc = 0
        self.entry_col_inc = 1
        self.core_range = range(1, 5)

        for y in self.core_range:
            self.core_text = self.core_string + str(y) + '_' + '25'
            self.core_label = Label(root, text = self.core_text)
            self.entry = Entry(root)
            self.core_label.grid(row=1, column=self.label_col_inc, sticky=E)
            self.entry.grid(row=1, column=self.entry_col_inc)
            self.entries.append(self.entry)
            self.label_col_inc += 2
            self.entry_col_inc += 2
    
        self.threshold_label = Label(root, text = "Threshold in nm")
        self.entry_threshold = Entry(root)

        self.threshold_label.grid(row = 2, sticky = E)
        self.entry_threshold.grid(row = 2, column = 1)
    
        self.light_label = Label(root, text = 'Status')
        self.light_label.grid(row = 3, column = 3)

        self.canvas = Canvas(root, width = 150, height = 50)
        self.canvas.grid(row = 4, column = 3)
    
        # Green light
        self.green_light = turtle.RawTurtle(self.canvas)
        self.green_light.shape('circle')
        self.green_light.color('grey')
        self.green_light.penup()
        self.green_light.goto(0,0)

        # Red light
        self.red_light = turtle.RawTurtle(self.canvas)
        self.red_light.shape('circle')
        self.red_light.color('grey')
        self.red_light.penup()
        self.red_light.goto(40,0)
    
        self.data_button = Button(root, text = "Get data above threshold", command = self.getData)
        self.data_button.grid(row = 5, column = 0)

#dataNo_label = Label(root, text = "Number of data to be collected")
#entry_datNo = Entry(root)

#dataNo_label.grid(row = 3, sticky = E)
#entry_datNo.grid(row = 3, column = 1)

# function to receive TCP data blocks
    def getData(self):
    #start = timeit.default_timer()
        host = '127.0.0.1'
        port = 5000
        s = socket.socket()
        s.connect((host, port))

        len_message = s.recv(4)
# input of the number of data to be received
    #dataNo = float(entry_datNo.get())

        while len_message:
            #bytes_length = int.from_bytes(len_message,'big') # for the software
            bytes_length = int(len_message.decode('utf-8')) # for the self-made server
            recvd_data = s.recv(bytes_length)
            self.buff_data.put(recvd_data) # puts in the buffer
            len_message = s.recv(4) # receives data blocks
            Thread(target = self.calculate_threshold).start() # in parallel calls function to calculate threshold and write to file
        
        else:
            print('out of loop')
            #stop = timeit.default_timer()
            print('Time: ', stop - start)
        s.close()
        
        
    def calculate_threshold(self):
            rmv_data = self.buff_data.get()
            stringdata = rmv_data.decode('utf-8')
            rep_str = stringdata.replace(",", ".")
            splitstr = rep_str.split()

            # received wavelength values
            inc = 34
            wav_threshold = []
            for y in self.entries:
                straight_wav = float(y.get())
                wav = float(splitstr[inc])
                wav_diff = wav - straight_wav
                if wav_diff < 0:
                    wav_diff = wav_diff * (-1)
                wav_threshold.append(wav_diff)
                inc += 56

            threshold = float(self.entry_threshold.get())

            # writing into the file
            data = []
            inc1 = 0
            col1 = 2
            col2 = 6

            data.insert(0, (str(splitstr[0])))
            data.insert(1, (str(splitstr[1])))

            for x in wav_threshold:
                if (x > threshold):
                    red_light.color('red')
                    green_light.color('grey')
                    data.insert(col1, (str(splitstr[34 + inc1])))
                    data.insert(col2,(str(x)))
                else:
                    red_light.color('grey')
                    green_light.color('green')
                    data.insert(col1,'-')
                    data.insert(col2,'-')
                inc1 += 56
                col1 += 1
                col2 += 1

            self.write_file(data)



# function to write into the file
    def write_file(self,data):
        with open("Output.txt", "a") as text_file:
            text_file.write('\t'.join(data[0:]))
            text_file.write('\n')


root = Tk()
gui = GUI(root)
root.mainloop()

Следующие это то, что я получаю в моем файле output.txt:

2020/03/05  14:42:05    -   1584.405    -   -   -   0.20000000000004547 -   -
2020/03/03  14:42:05    -   1584.405    -   -   -   0.20000000000004547 -   -
2020/03/04  14:42:05    -   1584.405    -   -   -   0.20000000000004547 -   -
2020/03/02  14:42:05    -   1584.405    -   -   -   0.20000000000004547 -   -

В то время как данные отправляются в следующем порядке:

2020/03/02  14:42:05
2020/03/03  14:42:05
2020/03/04  14:42:05
2020/03/05  14:42:05

Как узнать, вызывается ли функция параллельно в сокет, получающий следующие 4 байта? Потому что полученные блоки данных не в том же порядке, что и отправленные блоки данных. Любая помощь приветствуется. Заранее спасибо!