PyQt QMutex in worker and main thread - pyqt

Question

I want to lock the print function with a QMutex so only one thread can access it at a time. I wrote a very simple GUI with two buttons, one that quits the thread and one that tries to print something to see if the main thread blocks.
I've gotten it to work by making the lock a global variable but everyone in the internet says global variables are a bad idea. However declaring locks in the __init__ part of the Main Window and Worker class definitions as self.lock = QtCore.QMutex() does not provide the same behavior as when I declare it as a global variable.
What is the proper way to to ensure that the main thread will wait on the worker?
Below is the code for the global case:
import sys
from PyQt5 import QtWidgets, QtCore
import time
lock=QtCore.QMutex()
class expSignals(QtCore.QObject):
# =============================================================================
# Signal for quitting the thread. Dunno if should be seperate class or stati
# for main window
# =============================================================================
pause=QtCore.pyqtSignal()
class MyApp(QtWidgets.QMainWindow):
def __init__(self):
QtWidgets.QMainWindow.__init__(self)
# =============================================================================
# Create thread,worker, lock and move worker
# =============================================================================
self.thread=QtCore.QThread(self)
self.mot=motorpositioner()
self.mot.moveToThread(self.thread)
# =============================================================================
# Putting buttons and GUI stuff in place
# =============================================================================
self.button=QtWidgets.QPushButton('Quit thread',self)
self.button2=QtWidgets.QPushButton('Test locking',self)
layout = QtWidgets.QHBoxLayout()
layout.addWidget(self.button)
layout.addWidget(self.button2)
self.button2.move(0,50)
self.setLayout(layout)
self.setGeometry( 300, 300, 350, 300 )
# =============================================================================
# Making and connecting signals
# =============================================================================
self.qthread_sig=expSignals()
self.thread.started.connect(self.mot.do_it)
self.button.clicked.connect(self.qthread_sig.pause.emit)
self.button2.clicked.connect(self.test_lock)
self.qthread_sig.pause.connect(self.thread.quit)
# =============================================================================
# Start Thread
# =============================================================================
self.thread.start()
# =============================================================================
# Mutex should lock print
# =============================================================================
def test_lock(self):
#global lock
with QtCore.QMutexLocker(lock):
print('Printed in main thread')
def closeEvent(self,event):
self.qthread_sig.pause.emit()
event.accept()
class motorpositioner(QtCore.QObject):
def __init__(self):
QtCore.QThread.__init__(self)
# =============================================================================
# Create timer and lock, connect timer to print
# =============================================================================
self.timer = QtCore.QTimer(parent=self)
self.timer.timeout.connect(self.query_mot)
self.stat=0
#QtCore.pyqtSlot()
def do_it(self):
# =============================================================================
# Start timer
# =============================================================================
self.timer.start(5000)
#QtCore.pyqtSlot()
def query_mot(self):
#global lock
with QtCore.QMutexLocker(lock):
print('Printed in worker thread')
time.sleep(5)
if __name__ == "__main__":
if not QtWidgets.QApplication.instance():
app = QtWidgets.QApplication(sys.argv)
else:
app = QtWidgets.QApplication.instance()
window = MyApp()
window.show()
app.exec_()
I don't actually want to lock the print function but rather make sure that only one thread at a time talks to a positioning platform controlled from the PC.