Python - Change plot parameters in QThread

You currently have a signal connected to the plot method through self.worker.widgetplot.connect(self.WidgetPlot.plot), but you'll have a better time if you make a persistent plot - with a specific pen set, at your desired thickness - and then connect your widgetplot signal to that plot's setData method.

    # ... Ui_MainWindow.__init__
    self.plot_curve = self.WidgetPlot.plot(pen=mkPen("w", width=plotsize))

    # ... in my_class.__init__
    self.worker.widgetplot.connect(self.plot_curve.setData)

Based on what I have inferred from your request (i.e. you want just to use two different size for overlapping plot lines) I've rewritten your code with a series of improvements (in my humble opinion).

At the very core of the problem, what I've done is to create a separate pyqtgraph.PlotDataItem curve, plot it on top of your preview_line and handle a different size for it (completely randomic, please adjust the size as you desire). Thus, it's all about using

self.second_line.setData(x, y)

instead of recreating it every time with self.WidgetPlot.plot(...)

All the details are into the comments.

#PROGRAM/SCRIPT
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtWidgets import QApplication
import sys
import GUI
import datetime
import pyqtgraph
import time
plotsize = 20

# =============================================================================
# Threading for not freezing the GUI while running
# =============================================================================
class Worker(QtCore.QThread):
    progress = QtCore.pyqtSignal(int)
    finished = QtCore.pyqtSignal()
    widgetplot = QtCore.pyqtSignal(list, list)
    

    def __init__(self, plot_time, plot_value):
        QtCore.QThread.__init__(self, objectName='WorkerThread')

        # AS LONG AS YOU DON'T MODIFY plot_time and plot_value INTO THIS THREAD, they are thread-safe. 
        # If you intend to modify them in the future (into this thread), you need to implement a mutex/lock system to avoid races
        # Note that lists are mutable: you're storing the reference to the actual object that will always be edited into the MAIN THREAD
        self.plot_time = plot_time
        self.plot_value = plot_value

    def run(self):
        # This is naturally a LOCAL variable
        # self._count = 0
        _count = 0

        # --- This is useless, it plots ([], [])
        # self.widgetplot.emit(self.x, self.y) 
        # self.x = plot_time[:0]
        # self.y = plot_value[:0]
        # -----------------------------------
        _start_time = datetime.datetime.now()
        while 0 <= _count < 100:
            # Use local variable!
            _count_prev = _count
            QtCore.QThread.usleep(10000)
            _diff = datetime.datetime.now() - _start_time
            
            _count = int((_diff.total_seconds() * 10))
            if(_count != _count_prev):
                print(_count)
                x = self.plot_time[:_count]
                y = self.plot_value[:_count]

                # Since plot_time and plot_value are managed by main thread, you would just need to emit _count variable.
                # But I'll stick with your code
                self.widgetplot.emit(x, y)


class my_class(QtWidgets.QMainWindow, GUI.Ui_MainWindow):
    def __init__(self, parent=None):
        super(my_class, self).__init__(parent)
        self.setupUi(self)
        
        # In your version, the range is constant irrespective of the data being updated. It can be moved here
        self.WidgetPlot.setXRange(0, 105, padding=0)
        self.WidgetPlot.setYRange(0, 105, padding=0)

        # Create and store ONE line, you will change just the underlying data, not the object itself. WAY MORE efficient
        # Different pen with different plot size. Is this what you're seeking?
        self.second_line = pyqtgraph.PlotDataItem(pen=pyqtgraph.mkPen('w', width=plotsize*2))
        
        
        # Here class variable initialization goes
        self.plot_time = []
        self.plot_value = []

        # You don't need `moveToThread`. You can just subclass QThread 
        self.worker_thread = Worker(self.plot_time, self.plot_value)

        # I changed the name just to highlight the fact it is just an update and not a plot rebuilt
        self.worker_thread.widgetplot.connect(self.update_second_line_plot)

        self.pushButton.clicked.connect(self.my_function)

        self.WidgetPlot.setMouseEnabled(x=False, y=False)
        font=QtGui.QFont()
        font.setPixelSize(20)
        font.setBold(True)
        self.WidgetPlot.getAxis("bottom").setTickFont(font)
        self.WidgetPlot.getAxis("left").setTickFont(font)


    def my_function(self):
        # Use class variable instead, see the __init__

        # ...Not efficient
        # for i in range(100):
        #    plot_time.append(i)
        #    plot_value.append(i)

        # Better:
        _l = list(range(100))
        self.plot_time.extend(_l)
        self.plot_value.extend(_l)
        # DON'T DO self.plot_time = list(range(100)) --> it will recreate a new object, but this one is shared with the worker thread!

        self.start()
        
    def update_second_line_plot(self, plot_time, plot_value):
        # Just update the UNDERLYING data of your curve
        self.second_line.setData(plot_time, plot_value)


    def start(self):
        # First plot preview_plot. done ONCE
        self.WidgetPlot.plot(self.plot_time, self.plot_value, pen=pyqtgraph.mkPen('r', width=plotsize))

        # Add NOW the new line to be drawn ON TOP of the preview one
        self.WidgetPlot.addItem(self.second_line)
    
        # It automatically will do the job. You don't need any plotfunction
        self.worker_thread.start()    
    


def main():
    app = QApplication(sys.argv)
    form = my_class()
    form.show()
    app.exec_()
    
    
if __name__ == '__main__':
    main()

The result: