多线程同步操作多个窗口
线程同步的方法有哪些
线程同步的方法有哪些线程同步是多线程编程中非常重要的一个概念，它是指多个线程在访问共享资源时，为了避免出现数据不一致或者冲突的情况，需要对线程进行协调和同步。
在实际的开发中，我们常常会遇到需要进行线程同步的情况，因此了解线程同步的方法是非常重要的。
本文将介绍几种常见的线程同步方法，希望能够帮助大家更好地理解和应用线程同步。
1. 互斥锁。
互斥锁是最常见的线程同步方法之一。
它通过对共享资源加锁的方式，保证同一时间只有一个线程可以访问该资源，其他线程需要等待锁的释放才能访问。
互斥锁可以使用操作系统提供的原子操作指令来实现，也可以使用编程语言提供的锁机制来实现，如Java中的synchronized关键字。
2. 信号量。
信号量是另一种常见的线程同步方法。
它可以用来控制对共享资源的访问权限，通过对信号量的值进行操作来实现线程的同步。
当信号量的值大于0时，表示资源可用，线程可以访问；当信号量的值等于0时，表示资源不可用，线程需要等待。
信号量的实现可以使用操作系统提供的信号量机制，也可以使用编程语言提供的信号量类来实现。
3. 条件变量。
条件变量是一种线程同步的高级方法，它可以用来在多个线程之间传递信息和控制线程的执行顺序。
条件变量通常和互斥锁一起使用，当共享资源的状态发生变化时，可以通过条件变量来通知等待的线程。
条件变量的实现通常需要依赖于操作系统提供的条件变量机制或者编程语言提供的条件变量类。
4. 读写锁。
读写锁是一种特殊的互斥锁，它可以提高对共享资源的并发访问性能。
读写锁允许多个线程同时对共享资源进行读操作，但是在进行写操作时需要互斥访问。
通过读写锁，可以有效地提高对共享资源的并发性能，适用于读操作频繁、写操作较少的场景。
5. 原子操作。
原子操作是一种特殊的指令序列，它可以保证在多线程环境下对共享资源的操作是原子性的，不会被中断。
原子操作通常由硬件提供支持，可以保证在执行过程中不会被其他线程打断，从而保证对共享资源的操作是线程安全的。
多线程并发执行的例子
多线程并发执行的例子
1. 你看玩游戏的时候，那各种场景和角色同时在屏幕上活动，这可不就是多线程并发执行嘛！就像你操控着主角在打怪升级，旁边的小怪也在自顾自地跑来跑去，还有各种特效同时出现，这多神奇啊！
2. 大家想想，医院的挂号系统，那么多人同时在不同地方预约挂号，系统得同时处理好多请求，这就是很典型的多线程并发执行呀！这不就好比同时有好多人在跟医院这个“大脑”说话，它还能有条不紊地处理好。
3. 日常我们上网购物，你在浏览商品的时候，其他人也在下单购买，还有人在评价商品，这一切不都在同时进行吗？这多像一场热闹的集市啊，每个人都在做自己的事情，互不干扰，却又同时发生着，这就是多线程并发执行的魅力啊！
4. 在交通路口，信号灯控制着不同方向的车辆和行人，同时有车在直行，有车在转弯，行人也在过马路，这难道不算是多线程并发执行吗？这跟一个乐团演奏似的，各种乐器发出不同声音，但又那么和谐！
5. 我们使用的手机，一边在播放音乐，一边你还能聊天、刷网页，这些不都是同时进行的吗？这不就像一个人可以同时做好几件事一样，牛不牛？
6. 大公司的办公系统，好多部门的人都在使用，有人在提交文件，有人在查询数据，这也是多线程并发执行呀！就像一场盛大的演出，每个演员都有自己的戏份。
7. 视频网站上，那么多人同时在线观看不同的视频，服务器要同时给大家提供服务，这是不是很厉害？这多像好多人同时在不同的房间看不同的节目呀！
8. 智能语音助手，你跟它说话的同时，它还能处理其他任务，这不也是多线程并发执行嘛！感觉就像它有好多只手同时在做事。
我觉得多线程并发执行真的太重要了，让我们的生活变得更加高效和有趣！。
多线程同步有几种实现方法
多线程同步有几种实现方法
多线程同步有几种实现方法，常见的有以下几种：
1. 互斥锁：通过互斥锁（Mutex）来控制多个线程对共享资源的访问。
同一时间只允许一个线程访问共享资源，其他线程需要等待锁的释放才能进行访问。
2. 条件变量：通过条件变量（Condition Variable）可以使一个线程等待特定的条件发生，当条件满足时，线程重新获得锁并继续执行。
常用的条件变量有信号量和事件。
3. 信号量：信号量（Semaphore）是一种通过计数器来实现线程间同步的机制。
当计数器大于0时，线程可以执行，当计数器等于0时，线程需要等待。
信号量可以用于限制同时访问某个资源的线程数量。
4. 事件：事件（Event）是一种通过线程等待和通知来实现同步的机制。
线程等待某个事件发生后才能继续执行，其他线程可以通过触发事件来通知等待的线程。
5. 自旋锁：自旋锁是一种忙等的方式，线程在获取锁时，如果发现锁被其他线程占用，就会一直循环尝试获取锁，直到成功获取。
6. 屏障：屏障（Barrier）是一种等待所有线程都达到某个状态后再继续执行的机制。
当所有线程都到达屏障点后，屏障才会打开，线程可以继续执行。
这些方法可以根据具体的场景和需求选择合适的方式来进行多线程同步。
tcp服务器端使用多线程技术同时与多个客户通信的编程方法
tcp服务器端使用多线程技术同时与多个客户通信的编程方法在TCP服务器端使用多线程技术同时与多个客户通信，通常需要使用一些编程语言和框架来实现。
以下是一个使用Python和其标准库中的socket 和threading模块来实现的简单示例：```pythonimport socketimport threading创建一个socket对象server_socket = (_INET, _STREAM)绑定到特定的IP地址和端口server_(('',监听连接，最大连接数为10server_(10)存储线程的列表threads = []def handle_client(client_socket):"""处理客户端连接的函数"""while True:接收客户端发送的数据data = client_(1024)if not data:break处理数据...print(f"Received from client: {()}")关闭客户端连接client_()while True:接受客户端的连接请求，并返回一个新的socket对象（用于与该客户端通信）client_socket, address = server_()print(f"Connection from {address} has been established!") 创建新线程来处理这个客户端的连接thread = (target=handle_client, args=(client_socket,))() 开始线程(thread) 将线程添加到线程列表中等待所有线程完成（即等待所有客户端连接关闭）for thread in threads:()关闭服务器端socketserver_()```这个示例创建了一个TCP服务器，它监听本地的12345端口。
qt 线程同步的3种方法
qt 线程同步的3种方法
Qt提供了三种主要的方法来进行线程间的同步：信号与槽（Signals and Slots）、互斥锁（Mutexes）和条件变量（Condition Variables）。
1. 信号与槽（Signals and Slots）：这是Qt的核心特性之一，用于在不同线程之间进行通信。
信号是当某个事件发生时发出的，而槽是用来响应这个信号的函数。
信号和槽机制是线程间通信的一种有效方式，它允许线程之间异步地传递信息。
2. 互斥锁（Mutexes）：互斥锁用于保护共享数据，防止多个线程同时访问。
当一个线程需要访问共享数据时，它首先需要获取互斥锁。
如果互斥锁已经被其他线程持有，那么尝试获取锁的线程将被阻塞，直到锁被释放。
Qt的QMutex类提供了这种功能。
3. 条件变量（Condition Variables）：条件变量用于线程间的同步。
它们
通常与互斥锁一起使用，允许线程等待某个条件的发生。
当条件满足时，一个线程会通知其他等待的线程。
Qt的QWaitCondition类提供了条件变量
的功能。
这些方法可以帮助你确保多线程应用程序的正确运行，并防止数据竞争和其他并发问题。
多线程同步的几种方法
多线程同步的几种方法
多线程同步的几种方法主要包括临界区、互斥量、信号量、事件和读写锁等。
这些方法可以有效地控制多个线程对共享资源的访问，避免出现数据不一致和线程冲突的问题。
1．临界区：通过临界区实现多个线程对某一公共资源或一段代码的串行访问，可以保证某一时刻只有一个线程访问某一资源，速度快，适合控制数据的访问。
2．互斥量：互斥量是最简单的同步机制，即互斥锁。
多个进程（线程）均可以访问到一个互斥量，通过对互斥量加锁，从而来保护一个临界区，防止其它进程（线程）同时进入临界区，保护临界资源互斥访问。
3．信号量：信号量可以控制有限用户对同一资源的的访问而设计。
4．事件：通过通知线程的有一些事件已经发生，从而可以启动后续的任务执行。
5．读写锁：读写锁适合于使用在读操作多、写操作少的情况，比如数据库。
读写锁读锁可以同时加很多，但是写锁是互斥的。
当有进程或者线程要写时，必须等待所有的读进程或者线程都释放自己的读锁方可以写。
数据库很多时候可能只是做一些查询。
以上信息仅供参考，如有需要，建议咨询专业编程技术
人员。
多线程之线程同步的方法（7种）
多线程之线程同步的⽅法（7种）同步的⽅法：⼀、同步⽅法 即有synchronized关键字修饰的⽅法。
由于java的每个对象都有⼀个内置锁，当⽤此关键字修饰⽅法时，内置锁会保护整个⽅法。
在调⽤该⽅法前，需要获得内置锁，否则就处于阻塞状态。
注： synchronized关键字也可以修饰静态⽅法，此时如果调⽤该静态⽅法，将会锁住整个类。
⼆、同步代码块 即有synchronized关键字修饰的语句块。
被该关键字修饰的语句块会⾃动被加上内置锁，从⽽实现同步代码如：synchronized(object){}注：同步是⼀种⾼开销的操作，因此应该尽量减少同步的内容。
通常没有必要同步整个⽅法，使⽤synchronized代码块同步关键代码即可。
package com.xhj.thread;/*** 线程同步的运⽤** @author XIEHEJUN**/public class SynchronizedThread {class Bank {private int account = 100;public int getAccount() {return account;}/*** ⽤同步⽅法实现** @param money*/public synchronized void save(int money) {account += money;}/*** ⽤同步代码块实现** @param money*/public void save1(int money) {synchronized (this) {account += money;}}}class NewThread implements Runnable {private Bank bank;public NewThread(Bank bank) {this.bank = bank;}@Overridepublic void run() {for (int i = 0; i < 10; i++) {// bank.save1(10);bank.save(10);System.out.println(i + "账户余额为：" + bank.getAccount());}}}/*** 建⽴线程，调⽤内部类*/public void useThread() {Bank bank = new Bank();NewThread new_thread = new NewThread(bank);System.out.println("线程1");Thread thread1 = new Thread(new_thread);thread1.start();System.out.println("线程2");Thread thread2 = new Thread(new_thread);thread2.start();}public static void main(String[] args) {SynchronizedThread st = new SynchronizedThread();eThread();}}=====================================⽰例加讲解同步是多线程中的重要概念。
多线程的应用场景简书
多线程的应用场景简书
多线程的应用场景有很多，下面列举几个常见的例子：
1. 图片或视频处理：在图像或视频处理领域，通常需要对大量的图像或视频进行处理，例如图像的压缩、滤镜的应用等。
使用多线程可以同时处理多个图像或视频，提高处理速度和效率。
2. 网络编程：在网络编程中，多线程可以用来处理多个客户端的请求，例如Web服务器。
每个客户端请求都可以分配一个
线程来处理，提高同时处理请求的能力。
3. 并发编程：在并发编程中，多线程可以用来处理多个并发任务，例如并发访问数据库、并发执行任务等。
通过多线程可以提高系统的处理能力和资源利用率。
4. 数据分析与计算：在大数据处理和分析中，通常需要对海量数据进行处理和计算，使用多线程可以将数据分成多个部分并行处理，加快计算速度。
5. 用户界面响应：在图形界面应用程序中，如果某个操作需要耗费较长时间，使用多线程可以使界面仍然保持响应，提高用户体验。
需要注意的是，在使用多线程时需要注意线程的同步和竞态条件的处理，以避免出现线程安全问题。
多线程编程中的同步和并发问题解析
多线程编程中的同步和并发问题解析在多线程编程中，同步和并发是两个关键的概念，主要涉及到多个线程之间的协同工作和共享资源的管理。
了解和解决同步和并发问题是保证多线程程序正确执行的关键。
一、同步问题同步问题是指多个线程之间的协作和按照一定的顺序执行。
在多线程编程中，可能会遇到以下几种同步问题：1.竞态条件（Race Condition）：竞态条件是指多个线程竞争共享资源导致的问题。
当多个线程对同一共享资源进行读写操作时，可能会出现不可预期的结果。
例如，一个线程在读取共享资源的同时，另一个线程可能在修改这个资源，导致读取的结果不正确。
解决竞态条件的常见方法是使用互斥锁（Mutex）来保证对共享资源的排他访问，确保同一时间只有一个线程能够对共享资源进行操作。
2.死锁（Deadlock）：死锁是指多个线程互相等待对方释放资源导致的无法继续执行的情况。
当多个线程都在等待对方释放资源时，将无法继续执行下去，形成死锁。
解决死锁问题的方法可以使用资源分级策略，即按照一定的顺序请求资源，释放资源也按照相反的顺序进行。
这样能够避免多个线程同时请求相同的资源，从而降低死锁的可能性。
3.饥饿（Starvation）：饥饿是指某个线程由于资源被其他优先级高的线程占用而无法获得所需的资源，无法继续执行的情况。
解决饥饿问题的方法可以使用公平调度策略，即按照请求的先后顺序分配资源，避免某个线程长时间无法获得资源的情况。
二、并发问题并发问题是指多个线程同时执行，可能会导致不可预期的结果。
在多线程编程中，可能会遇到以下几种并发问题：1.数据竞争（Data Race）：数据竞争是指多个线程同时读写共享数据导致的问题。
当多个线程对同一数据进行读写操作时，可能会出现不一致的结果。
例如，一个线程正在写入数据，同时另一个线程正在读取这个数据，导致读取的结果不正确。
解决数据竞争问题的常见方法是使用原子操作（Atomic Operation）或者互斥锁来保证对共享数据的原子性操作，确保多个线程对数据的访问不会出现冲突。
C#多线程间同步的例子（多个线程做同件事情）
C#多线程间同步的例子（多个线程做同件事情）注意：lock用于一个对象只能同时被一个线程访问，Monitor用于多个线程同时访问一个对象。
本博客有关多线程的文章：•C#多线程编程（1）：线程的启动•多线程编程(2)：线程的同步•多线程编程(3)：线程池ThreadPool•多线程编程(4)：多线程与UI操作在开发中经常会遇到线程的例子，如果某个后台操作比较费时间，我们就可以启动一个线程去执行那个费时的操作，同时程序继续执行。
在某些情况下可能会出现多个线程的同步协同的问题，下面的例子就展示了在两个线程之间如何协同工作。
这个程序的思路是共同做一件事情（从一个ArrayList中删除元素）,如果执行完成了，两个线程都停止执行。
代码如下：///作者：周公///时间：2008-5-17///原发地址：/zhoufoxcn///</summary>public class ThreadDemo{private Thread threadOne;private Thread threadTwo;private ArrayList stringList;private event EventHandler OnNumberClear;//数据删除完成引发的事件public static void Main(){ThreadDemo demo = new ThreadDemo(1000);demo.Action();}public ThreadDemo(int number){Random random = new Random(1000000);stringList = new ArrayList(number);for (int i = 0; i < number; i++){stringList.Add(random.Next().ToString());}threadOne = new Thread(new ThreadStart(Run));//两个线程共同做一件事情threadTwo = new Thread(new ThreadStart(Run));//两个线程共同做一件事情 = "线程1"; = "线程2";OnNumberClear += new EventHandler(ThreadDemo_OnNu mberClear);}///<summary>///开始工作///</summary>public void Action(){threadOne.Start();threadTwo.Start();}///<summary>///共同做的工作///</summary>private void Run(){string stringValue = null;while (true){Monitor.Enter(this);//锁定，保持同步stringValue = (string)stringList[0];Console.WriteLine( + "删除了" + stringValue);stringList.RemoveAt(0);//删除ArrayList中的元素if (stringList.Count == 0){OnNumberClear(this, new EventArgs());//引发完成事件}Monitor.Exit(this);//取消锁定说明：要实现线程同步不止这一种方式。
PYQT5开启多个线程和窗口,多线程与多窗口的交互实例
PYQT5开启多个线程和窗⼝,多线程与多窗⼝的交互实例每点击⼀次按钮,弹出⼀个对话框(⼦窗⼝),同时开启⼀个⼦线程来执⾏任务并更新对话框内容,关闭对话框则关闭对应⼦线程1. 建⽴⼀个简单的主界⾯和⼀个⾃定义对话框from PyQt5 import QtCore, QtGui, QtWidgetsclass Ui_MainWindow(object):def setupUi(self, MainWindow):MainWindow.setObjectName("MainWindow")MainWindow.resize(327, 303)self.centralwidget = QtWidgets.QWidget(MainWindow)self.centralwidget.setObjectName("centralwidget")self.gridLayout = QtWidgets.QGridLayout(self.centralwidget)self.gridLayout.setObjectName("gridLayout")spacerItem = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)self.gridLayout.addItem(spacerItem, 0, 0, 1, 1)self.pushButton = QtWidgets.QPushButton(self.centralwidget)self.pushButton.setObjectName("pushButton")self.gridLayout.addWidget(self.pushButton, 0, 1, 1, 1)spacerItem1 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)self.gridLayout.addItem(spacerItem1, 0, 2, 1, 1)MainWindow.setCentralWidget(self.centralwidget)self.menubar = QtWidgets.QMenuBar(MainWindow)self.menubar.setGeometry(QtCore.QRect(0, 0, 327, 23))self.menubar.setObjectName("menubar")MainWindow.setMenuBar(self.menubar)self.statusbar = QtWidgets.QStatusBar(MainWindow)self.statusbar.setObjectName("statusbar")MainWindow.setStatusBar(self.statusbar)self.retranslateUi(MainWindow)self.pushButton.clicked.connect(MainWindow.open_dialog)QtCore.QMetaObject.connectSlotsByName(MainWindow)def retranslateUi(self, MainWindow):_translate = QtCore.QCoreApplication.translateMainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))self.pushButton.setText(_translate("MainWindow", "多线程弹窗"))class Ui_Dialog(object):def setupUi(self, Dialog):Dialog.setObjectName("Dialog")Dialog.resize(369, 128)self.gridLayout = QtWidgets.QGridLayout(Dialog)self.gridLayout.setObjectName("gridLayout")self.buttonBox = QtWidgets.QDialogButtonBox(Dialog)self.buttonBox.setOrientation(QtCore.Qt.Horizontal)self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel|QtWidgets.QDialogButtonBox.Ok)self.buttonBox.setObjectName("buttonBox")self.gridLayout.addWidget(self.buttonBox, 1, 0, 1, 1)self.progressBar = QtWidgets.QProgressBar(Dialog)self.progressBar.setProperty("value", 24)self.progressBar.setObjectName("progressBar")self.gridLayout.addWidget(self.progressBar, 0, 0, 1, 1)self.retranslateUi(Dialog)self.buttonBox.accepted.connect(Dialog.accept)self.buttonBox.rejected.connect(Dialog.reject)QtCore.QMetaObject.connectSlotsByName(Dialog)def retranslateUi(self, Dialog):_translate = QtCore.QCoreApplication.translateDialog.setWindowTitle(_translate("Dialog", "Dialog"))2. 每点击⼀次按钮,打开⼀个弹窗class DialogWindow(QDialog, Ui_Dialog):def __init__(self, parent=None):super(DialogWindow, self).__init__(parent)self.setupUi(self)class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):def __init__(self, parent=None):super(MainWindow, self).__init__(parent)self.setupUi(self)def open_dialog(self):dialog = DialogWindow(self)dialog.show()if __name__ == "__main__":app = QtWidgets.QApplication(sys.argv)mainWindow = MainWindow()mainWindow.show()sys.exit(app.exec_())3. 打开弹窗的同时,打开⼀个⼦线程,更新对话框中的进度条在⼦线程定义信号,关联对话框更新进度条的槽函数class DialogWindow(QDialog, Ui_Dialog):def __init__(self, parent=None):super(DialogWindow, self).__init__(parent)self.setupUi(self)def update_progressbar(self, p_int):self.progressBar.setValue(p_int) # 更新进度条class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):def __init__(self, parent=None):super(MainWindow, self).__init__(parent)self.setupUi(self)self.count = 0def open_dialog(self):dialog = DialogWindow(self)dialog.show()self.thread = RunThread(self.count)self.count += 1self.thread.update_pb.connect(dialog.update_progressbar) # 关联self.thread.start()class RunThread(QThread):update_pb = pyqtSignal(int) # 定义更新进度条的信号def __init__(self, count):super().__init__()self.count = countdef run(self):for i in range(100):print('thread%s' % self.count, i, QThread().currentThreadId())self.update_pb.emit(i)time.sleep(1)passif __name__ == "__main__":app = QtWidgets.QApplication(sys.argv)mainWindow = MainWindow()mainWindow.show()sys.exit(app.exec_())4. 关闭对话框,则关闭对应⼦线程在对话框中添加⾃定义信号,并重写关闭事件,在关闭窗⼝时发送关闭⼦线程的信号class DialogWindow(QDialog, Ui_Dialog):stop_thread = pyqtSignal() # 定义关闭⼦线程的信号def __init__(self, parent=None):super(DialogWindow, self).__init__(parent)self.setupUi(self)def update_progressbar(self, p_int):self.progressBar.setValue(p_int)def closeEvent(self, event):self.stop_thread.emit()passclass MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):def __init__(self, parent=None):super(MainWindow, self).__init__(parent)self.setupUi(self)self.count = 0def open_dialog(self):dialog = DialogWindow(self)dialog.show()self.thread = RunThread(self.count)self.count += 1self.thread.update_pb.connect(dialog.update_progressbar)dialog.stop_thread.connect(self.thread.terminate)self.thread.start()class RunThread(QThread):update_pb = pyqtSignal(int)def __init__(self, count):super().__init__()self.count = countdef run(self):for i in range(1, 101):print('thread_%s' % self.count, i, QThread().currentThreadId())self.update_pb.emit(i)time.sleep(1)passif __name__ == "__main__":app = QtWidgets.QApplication(sys.argv)mainWindow = MainWindow()mainWindow.show()sys.exit(app.exec_())5. 使⽤线程池QThreadPool管理⼦线程使⽤QThreadPool, 线程需要继承QRunnable,⽽QRunnable只是namespace,没有继承QT的信号机制,所以需要另外继承QObject来使⽤信号,我这⾥直接在线程中使⽤封装的信号向外部传递信息class DialogWindow(QDialog, Ui_Dialog):stop_thread = pyqtSignal() # 定义关闭⼦线程的信号def __init__(self, parent=None):super(DialogWindow, self).__init__(parent)self.setupUi(self)def update_progressbar(self, p_int):self.progressBar.setValue(p_int)def closeEvent(self, event):self.stop_thread.emit()passclass MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):def __init__(self, parent=None):super(MainWindow, self).__init__(parent)self.setupUi(self)self.count = 0self.pool = QThreadPool()self.pool.globalInstance()self.pool.setMaxThreadCount(10) # 设置最⼤线程数def open_dialog(self):dialog = DialogWindow(self)dialog.show()thread = RunThread(self.count)self.count += 1thread.signal.update_pb.connect(dialog.update_progressbar)# dialog.stop_thread.connect(thread.stop)# self.thread.start()self.pool.start(thread) # 线程池分配⼀个线程运⾏该任务class Signal(QObject):update_pb = pyqtSignal(int)class RunThread(QRunnable):def __init__(self, count):super().__init__()self.count = countself.signal = Signal() # 信号def run(self):for i in range(1, 101):print('thread_%s' % self.count, i, QThread().currentThreadId())self.signal.update_pb.emit(i)time.sleep(1)if __name__ == "__main__":app = QtWidgets.QApplication(sys.argv)mainWindow = MainWindow()mainWindow.show()sys.exit(app.exec_())QThreadPool没有释放正在运⾏的线程的⽅法以上这篇PYQT5开启多个线程和窗⼝,多线程与多窗⼝的交互实例就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。
多线程同步与互斥 方法
多线程同步与互斥方法
多线程同步和互斥是为了保证多个线程能够安全地访问共享资源而采取的措施。
下面是几种常见的多线程同步与互斥的方法：
1. 锁（lock）：通过加锁的方式来保护临界区，只有获得锁的线程才能进入临界区执行代码，其他线程需要等待锁的释放。
常见的锁包括互斥锁（mutex）和读写锁（read-write lock）。
2. 信号量（semaphore）：允许多个线程同时访问某个资源，但要限制同时访问的线程数量，通过信号量进行计数来实现。
3. 条件变量（condition variable）：允许线程在某个条件满足时等待，直到其他线程发出信号通知它们继续执行。
4. 互斥量（mutex）：一种特殊的锁，用于确保某段代码只能被一个线程执行，其他线程需要等待。
5. 读写锁（read-write lock）：允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。
6. 自旋锁（spin lock）：不会引起线程的阻塞，在尝试获取锁时，会一直处于循环中直到获取到锁为止。
7. 可重入锁（reentrant lock）：允许同一线程多次获取同一个锁而不会发生死锁。
以上方法都是为了解决多线程之间的冲突和竞争条件问题，保证线程安全和数据一致性。
根据具体的场景和需求，选择适合的同步与互斥方法可以提高多线程程序的性能和正确性。
多线程同步的四种方式（史上最详细+用例）
多线程同步的四种⽅式（史上最详细+⽤例）多线程同步的四种⽅式对于多线程程序来说，同步是指在⼀定的时间内只允许某⼀个线程来访问某个资源。
⽽在此时间内，不允许其他的线程访问该资源。
可以通过互斥锁（Mutex）、条件变量（condition variable）、读写锁（reader-writer lock）、信号量（semaphore）来同步资源。
1. 互斥锁（Mutex）互斥量是最简单的同步机制，即互斥锁。
多个进程(线程)均可以访问到⼀个互斥量，通过对互斥量加锁，从⽽来保护⼀个临界区,防⽌其它进程(线程)同时进⼊临界区，保护临界资源互斥访问。
互斥锁需要满⾜三个条件：互斥不同线程的临界区没有重叠⽆死锁如果⼀个线程正在尝试获得⼀个锁，那么总会成功地获得这个锁。
若线程A调⽤lock()但是⽆法获得锁，则⼀定存在其他线程正在⽆穷次地执⾏临界区。
⽆饥饿每⼀个试图获得锁的线程最终都能成功。
#include <stdio.h>#include <stdlib.h>#include <pthread.h>void *function(void *arg);pthread_mutex_t mutex;int counter = 0;int main(int argc, char *argv[]){int rc1,rc2;char *str1="hello";char *str2="world";pthread_t thread1,thread2;pthread_mutex_init(&mutex,NULL);if((rc1 = pthread_create(&thread1,NULL,function,str1))){fprintf(stdout,"thread 1 create failed: %d\n",rc1);}if(rc2=pthread_create(&thread2,NULL,function,str2)){fprintf(stdout,"thread 2 create failed: %d\n",rc2);}pthread_join(thread1,NULL);pthread_join(thread2,NULL);return 0;}void *function(void *arg){char *m;m = (char *)arg;pthread_mutex_lock(&mutex);while(*m != '\0'){printf("%c",*m);fflush(stdout);m++;sleep(1);}printf("\n");pthread_mutex_unlock(&mutex);}2. 条件变量（condition variable）⽣产者消费者问题：每次⽣产⼀个商品，发⼀个信号，告诉消费者“我⽣产商品了，快来消费”，消费者拿到⽣产者的条件变量后每次消费两个商品，然后发出信号“我消费了商品，你可以⽣产了”--_--（发的这个信号是⼀个条件变量，通过发送这个信号可以唤醒阻塞的线程，收到信号后，不满⾜需求也会继续阻塞）为了防⽌竞争，条件变量的使⽤总是和⼀个互斥锁结合在⼀起；条件变量是线程的另⼀种同步机制，它和互斥量是⼀起使⽤的。
LinuxC实现多线程同步的四种方式（超级详细）
LinuxC实现多线程同步的四种方式（超级详细）背景问题：在特定的应用场景下，多线程不进行同步会造成什么问题？通过多线程模拟多窗口售票为例：#include <iostream>#include<pthread.h>#include<stdio.h>#include<stdlib.h>#include<string.h>#include<unistd.h>using namespace std;int ticket_sum=20;void *sell_ticket(void *arg){for(int i=0; i<20; i ){if(ticket_sum>0){sleep(1);cout<<'sell the '<<20-ticket_sum1<<'th'<<endl;ticket_sum--;}}return 0;}int main(){int flag;pthread_t tids[4];for(int i=0; i<4; i ){flag=pthread_create(&tids[i],NULL,&s ell_ticket,NULL);if(flag){cout<<'pthread create error ,flag='<<flag<<endl;return flag;}}sleep(20);void *ans;for(int i=0; i<4; i ){flag=pthread_join(tids[i],&ans);if(flag){cout<<'tid='<<tids[i]<<'join erro flag='<<flag<<endl;return flag;}cout<<'ans='<<ans<<endl;}return 0;}分析：总票数只有20张，却卖出了23张，是非常明显的超买超卖问题，而造成这个问题的根本原因就是同时发生的各个线程都可以对ticket_sum进行读取和写入！ps：1.在并发情况下，指令执行的先后顺序由内核决定，同一个线程内部，指令按照先后顺序执行，但不同线程之间的指令很难说清楚是哪一个先执行，如果运行的结果依赖于不同线程执行的先后的话，那么就会形成竞争条件，在这样的情况下，计算的结果很难预知，所以应该尽量避免竞争条件的形成2.最常见的解决竞争条件的方法是将原先分离的两个指令构成一个不可分割的原子操作，而其他任务不能插入到原子操作中！3.对多线程来说，同步指的是在一定时间内只允许某一个线程访问某个资源，而在此时间内，不允许其他线程访问该资源!4.线程同步的常见方法：互斥锁，条件变量，读写锁，信号量一.互斥锁本质就是一个特殊的全局变量，拥有lock和unlock两种状态，unlock的互斥锁可以由某个线程获得，一旦获得，这个互斥锁会锁上变成lock状态，此后只有该线程由权力打开该锁，其他线程想要获得互斥锁，必须得到互斥锁再次被打开之后采用互斥锁来同步资源:#include <iostream>#include<pthread.h>#include<stdio.h>#include<stdlib.h>#include<string.h>#include<unistd.h>using namespace std;int ticket_sum=20;pthread_mutex_tmutex_x=PTHREAD_MUTEX_INITIALIZER;//static init mutexvoid *sell_ticket(void *arg){for(int i=0; i<20; i ){pthread_mutex_lock(&mutex_x);//atomic opreation through mutex lockif(ticket_sum>0){sleep(1);cout<<'sell the '<<20-ticket_sum1<<'th'<<endl;ticket_sum--;}pthread_mutex_unlock(&mutex_x);return 0;}int main(){int flag;pthread_t tids[4];for(int i=0; i<4; i ){flag=pthread_create(&tids[i],NULL,&s ell_ticket,NULL);if(flag){cout<<'pthread create error ,flag='<<flag<<endl;return flag;}}sleep(20);void *ans;for(int i=0; i<4; i ){flag=pthread_join(tids[i],&ans);if(flag){cout<<'tid='<<tids[i]<<'join erro flag='<<flag<<endl;return flag;}cout<<'ans='<<ans<<endl;return 0;}分析：通过为售票的核心代码段加互斥锁使得其变成了一个原子性操作！不会被其他线程影响1.互斥锁的初始化互斥锁的初始化分为静态初始化和动态初始化静态：pthread_mutex_t mutex_x=PTHREAD_MUTEX_INITIALIZER;//static init mutex 动态：pthread_mutex_init函数ps：互斥锁静态初始化和动态初始化的区别？待补充。
好人多窗口同步器使用说明使用教程
好人多窗口使用教程
一、一台电脑多窗口操作流程：
双击打开这个文件，登录即可（新用户注册可以免费试用1小时，WIN7用户打开时要右击选择以管理员的身份运行噢）如下图所示：
完成后，点开始即可（小提示：里面的模式都可以调用的噢，模式的用处就是那个同步效果不好，都是可以换的噢，直到你感觉VERY good就OK了）
二、虚拟机、局域网机同步教程流程：
1、被控的电脑（不管是虚拟机还是局域网电脑，都可以按下面方法的
第一步把下面这个文件复制到要控制的电脑或虚拟机里。
（每台，多个虚拟机都要复制这个这文件噢，如下图所示：）
第二步，复制完后，打开，效果图如下图所示：（此软件在被控机或虚拟机中运行）
第三步局域网或虚拟机主机运行：（此软件在主机中运行）
最后，都设置好后，点开始键，主控软件和被控软件都要点开始按钮噢、完成后，就OK了噢，最后祝大家天天中大奖噢。
windows窗口同步器实现原理
windows窗口同步器实现原理一、引言在计算机操作系统中，同步机制是保证多个线程或进程之间正确协同工作的重要手段之一。
Windows操作系统提供了许多同步机制，其中窗口同步器是一种常用的同步机制，用于控制窗口的访问和响应。
二、窗口同步器的概念窗口同步器是一种用于管理窗口访问和响应的同步机制。
它能够保证同一时间只有一个线程能够访问窗口，并且能够确保窗口的响应是按顺序进行的。
三、窗口同步器的实现原理1. 互斥锁（Mutex）互斥锁是窗口同步器的核心组件之一。
每个窗口都有一个对应的互斥锁，用于控制窗口的访问。
当一个线程想要访问窗口时，它首先尝试获取窗口的互斥锁。
如果互斥锁已经被其他线程占用，则该线程会被阻塞，直到互斥锁被释放。
这样可以保证同一时间只有一个线程能够访问窗口，避免了多个线程同时修改窗口状态造成的错误。
2. 条件变量（Condition Variable）条件变量用于控制窗口的响应顺序。
当一个线程想要等待窗口的某个条件满足时，它可以通过条件变量进行等待。
当满足条件时，其他线程可以通过条件变量发出信号，通知等待线程继续执行。
这样可以确保窗口的响应是按顺序进行的，避免了多个线程同时响应窗口造成的错误。
3. 事件（Event）事件是窗口同步器的另一个重要组件。
它用于在窗口状态发生变化时通知其他线程。
当窗口状态发生变化时，窗口同步器会触发一个事件，其他线程可以通过监听该事件来得知窗口状态的变化并作出相应的处理。
这样可以保证窗口状态的变化能够及时通知其他线程，避免了线程之间的信息不一致。
四、窗口同步器的实现方式1. 使用互斥锁和条件变量最常见的窗口同步器实现方式是使用互斥锁和条件变量。
通过互斥锁控制窗口的访问，通过条件变量控制窗口的响应顺序。
这种方式简单易用，适用于大多数窗口应用。
2. 使用信号量（Semaphore）除了互斥锁和条件变量外，还可以使用信号量来实现窗口同步器。
信号量是一种计数器，用于控制对共享资源的访问。
窗口同步操作方法
窗口同步操作方法窗口同步操作方法是指在多线程或多进程编程中，为了避免出现资源竞争和数据不一致的问题，需要使用一些机制来控制多个线程或进程之间的并发访问。
窗口同步操作方法是一种常用的同步机制，在窗口应用程序中用于保护共享数据的一致性。
窗口同步操作方法主要有以下几种：1. 互斥锁：互斥锁是最基本的同步机制之一。
它用于保护共享资源，同一时刻只允许一个线程或进程访问该资源。
当一个线程或进程请求获取锁时，如果锁已经被其他线程或进程占用，则该线程或进程会被阻塞，直到锁被释放。
2. 信号量：信号量是一种更复杂的同步机制，它可以用来控制多个线程或进程的并发访问。
信号量可以设置一个初始值，并且可以增加或减少。
当一个线程或进程请求获取信号量时，如果信号量的值大于0，则减少信号量的值，并允许线程或进程继续执行；如果信号量的值等于0，则阻塞线程或进程，直到其他线程或进程释放信号量。
3. 条件变量：条件变量是一种用于线程之间相互通信的同步机制。
条件变量用于实现线程的等待和唤醒操作。
一个线程可以等待一个条件变量，直到其他线程满足某个条件后，通过唤醒操作通知等待线程可以继续执行。
4. 读写锁：读写锁用于支持多线程对一个共享资源进行读操作和写操作的同步管理。
它允许多个线程同时对共享资源进行读操作，但只允许一个线程进行写操作。
这可以提高读操作的并发性能，同时保证写操作的原子性。
5. 事件：事件是一种同步机制，用于通知一个或多个线程某个事件的发生。
在窗口应用程序中，事件可以用于线程之间的通信，比如通知某个线程有新的消息到达或任务完成。
6. 同步块：同步块是Java中一种基于对象的同步机制。
通过使用synchronized 关键字，可以将一段代码块声明为同步块，以实现对共享资源的互斥访问。
在同步块中，同一时刻只有一个线程可以执行，其他线程必须等待。
以上是窗口同步操作方法的一些常见实现方式，不同的应用场景可能需要选择不同的同步方法来解决同步问题。
用回调函数实现多线程同步
用回调函数实现多线程同步使用回调函数实现多线程同步多线程编程是一种常见的并发编程模型，能够有效提高程序的性能和响应速度。
然而，在多线程环境下，线程之间的同步问题会变得非常复杂。
为了解决这个问题，回调函数被广泛应用于多线程同步中。
回调函数是一种特殊的函数指针，它允许将一个函数作为参数传递给另一个函数，并在特定事件发生时被调用。
在多线程环境中，我们可以使用回调函数来实现线程之间的同步。
1. 线程创建和回调函数概述在多线程编程中，我们通常会创建多个线程来执行不同的任务。
为了实现线程之间的同步，我们可以在创建线程时指定一个回调函数，用于在线程完成任务后通知主线程。
2. 线程同步的步骤使用回调函数实现多线程同步的步骤如下：步骤一：定义一个回调函数，用于在线程完成任务后执行特定的操作。
步骤二：创建线程，并将定义的回调函数作为参数传递给线程。
步骤三：线程执行完任务后调用回调函数，并将任务结果作为参数传递给回调函数。
步骤四：在回调函数中执行特定的操作，如更新共享变量、发送信号等。
通过这种方式，我们可以在多线程环境中实现线程的同步和协作。
3. 示例代码下面是一个使用回调函数实现多线程同步的示例代码：```pythonimport threading# 定义回调函数，用于在线程完成后通知主线程def callback_func(result):print("线程执行完毕，结果为：", result)# 定义线程函数，执行耗时操作def thread_func(callback):# 执行具体的任务result = 1 + 2# 调用回调函数，将任务结果传递给回调函数callback(result)# 创建线程，并指定回调函数thread = threading.Thread(target=thread_func, args=(callback_func,))# 启动线程thread.start()# 主线程继续执行其他任务print("主线程继续执行")```在上述代码中，我们首先定义了一个回调函数`callback_func`，用于在线程完成后通知主线程。
窗口联动机制
窗口联动机制
窗口联动机制是一种在计算机操作系统中常见的功能，它允许多个窗口之间相互关联和交互。
通过窗口联动，用户可以在不同的窗口之间进行数据的传递、共享和同步操作，从而提高工作效率和用户体验。
例如，在一个文字处理软件中，用户可以同时打开多个窗口，分别编辑不同的文档。
通过窗口联动机制，用户可以方便地在这些窗口之间切换，复制、粘贴、拖拽文本内容，实现多文档的快速编辑和整理。
这种窗口联动的设计使得用户可以更加高效地处理大量文档，提升工作效率。
窗口联动机制还在其他应用场景中得到了广泛应用。
比如，在图像处理软件中，用户可以同时打开多个窗口，分别进行不同的图像编辑操作。
通过窗口联动，用户可以方便地在这些窗口之间切换，比较不同编辑效果，实现图像的多角度处理和对比。
这种窗口联动的设计使得用户可以更加直观地观察和调整图像效果，提升图像处理的质量和效率。
窗口联动机制还可以在多任务管理中发挥重要作用。
在操作系统中，用户可以同时打开多个应用程序，每个应用程序都会有一个独立的窗口。
通过窗口联动机制，用户可以方便地在这些窗口之间切换，管理和控制不同应用程序的运行状态。
这种窗口联动的设计使得用户可以更加方便地进行多任务操作，提高工作效率和系统的稳定性。
窗口联动机制是一种在计算机操作系统中非常实用的功能。
它通过多个窗口之间的关联和交互，提高了用户在不同应用场景下的工作效率和用户体验。
无论是在文字处理、图像处理还是多任务管理中，窗口联动机制都起到了重要的作用。
通过合理的设计和运用，窗口联动机制可以为用户带来更加便捷和高效的操作体验。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
多线程同步操作多个窗口RunApp "notepad.exe"RunApp "notepad.exe"RunApp "notepad.exe"Delay 2000Dimenv temp_Hwndtemp_Hwnd = 0Dim str, arr, istr = Plugin.Window.Search("无标题- 记事本")arr = Split(str, "|")For i = 0 To UBound(arr) - 1temp_Hwnd = Plugin.Window.FindEx(arr(i), 0, "Edit", 0)BeginThread WriteStringWhile temp_Hwnd <> 0'判断多线程已经启动完毕，继续循环下一个。
Delay 500WendNextEndScriptFunction WriteString()Dim str, HwndHwnd = temp_Hwndtemp_Hwnd = 0Dostr = WaitKeyIf Hwnd <> Plugin.Window.GetKeyFocusWnd ThenCall Plugin.Bkgnd.KeyPress(Hwnd, str)End IfLoopEnd Function多线程多开窗口同步执行与子线程间的数值如何传递：1.Dimenv IsThread, i2.Dim arr_Thread()3.For i = 0 To 24. IsThread = False'未启动线程5. Redim Preserve arr_Thread(i)6. arr_Thread(i) = BeginThread(EnterThread)7. While IsThread = False'未启动成功，等待中8. Delay 5009. Wend10. '跳出循环说明 IsThread = True，已经执行到了，循环继续启动下一个11.Next12.EndScript'结束主线，但子线程还会继续运行13.'函数调用//////////////////////////////////////////14.Function EnterThread()15. Dim n16. n = i17. IsThread = True18. Do19. TracePrint "运行线程：" & n20. Delay 50021. Loop22.End Function多线程运行中单独停止某个子线程演示：1.'环境变量声明2.Dimenv Hwnd, IsThread3.IsThread = False4.Do5. Hwnd = Plugin.Window.Find("Notepad", "无标题 - 记事本")6. If Hwnd = 0 Then7. RunApp "notepad.exe" : Delay 20008. TracePrint "运行记事本"9. End If10.Loop While Hwnd = 011.'获得记事本中输入子窗口句柄，以便按键输入内容12.Hwnd = Plugin.Window.FindEx(Hwnd, 0, "Edit", 0)13.'全局变量声明14.Dim IdThread15.'主循环↓16.Do17. If WaitKey() = 81 Then18. If IsThread = False Then19. IdThread = BeginThread(WriteString)20. Do21. TracePrint "等待线程启动！"22. Delay 50023. Loop While IsThread = False24. TracePrint "线程启动成功！"25. Else26. TracePrint "线程停止操作！"27. StopThread IdThread28. IsThread = False29. End If30. End If31.Loop32.'以下是函数区域↓33.Function WriteString()34. IsThread = True35. Do36. Call Plugin.Bkgnd.KeyPress(Hwnd, 65)37. Delay 50038. Loop39.End Function主线程逐个开启子线程五开操作演示：1.'五开操作2.Dim str_Hwnd3.str_Hwnd = vbNullString'记录都有哪些窗口句柄在运行4.DimEnv IsHwnd5.IsHwnd = 06.For i_win = 0 To 47. Do8. RunApp "notepad.exe"9. str = Plugin.Window.Search("无标题 - 记事本")10. arr = Split(str, "|")11. If str <> vbNullString Then12. For i = 0 To UBound(arr) - 113. If InStr(str_Hwnd, arr(i)) = 0 Then14. IsHwnd = arr(i)15. str_Hwnd = str_Hwnd & arr(i) & "|"16. Exit For17. End If18. Next19. Else20. IsHwnd = arr(0)21. End If22. Loop While IsHwnd = 023. Call Plugin.Window.SetClientSize(IsHwnd, 300, 300)24. Call Plugin.Window.Move(IsHwnd, 300 * i_win, 0)25. BeginThread 后台喊话26. Do27. Delay 100028. Loop Until Hwnd = 029.Next30.EndScript31.Function 后台喊话()32. Dim Hwnd33. Hwnd = Plugin.Window.FindEx(IsHwnd, 0, "Edit", 0)34. IsHwnd = 035. Do36. Call Plugin.Bkgnd.SendString(Hwnd, "文字测试")37. Call Plugin.Bkgnd.KeyPress(Hwnd, 13)38. Delay 50039. Loop40. End Function一、多线程是什么，可以干什么一般来说，我们编写的脚本都是一条道走到黑，最多加点循环、判断和跳转，程序始终是按部就班的执行指定的命令，只能同时干一件工作，让它取色就取色，让它单击就单击，不能同时完成两项以上的工作。
多线程的出现，是让脚本可以同时开展几项工作，在单击时，可以通过环境变量传过来取色子程序获得的坐标，而无需在每次单击命令前执行调用取色子程序。
当然这只是一个很简单的例子，像这样简单的情况，是没必要弄个多线程的，如果非要弄出多线程处理，反而要考虑到同步的问题：这边要单击了，那边取色命令传过来的坐标值，是多长时间以前的？或者直接取色命令还没执行完，这边到底单击哪里呢？有人说按键精灵的多线程是伪多线程，其实不管是真假多线程，对于电脑的CPU来说，同时只会做一件事情，只是说把各个线程传过来需要处理的东西按照时间先后和优先级的关系，排个队列挨个执行而已。
就像你去食堂打饭，很多人排队打，但是打饭的师傅只有一个，关系好的可能能插个队。
多核CPU大概是食堂有好几个窗口，这样的话，倒是有可能同时有几个同学在打饭。
那么，我们假设要做的工作是让一个寝室的同学聚餐，可以派一个人去打饭（单线程），或者派几个人去打饭（多线程）。
假设班长下达了命令：甲负责打菜，乙负责打饭，丙负责买汽水，其余的负责准备场地，那么什么时候开饭，应该要等到甲乙丙任务都完成了才行。
可以约定时间，也可以让每个人报告。
如果有一辆自行车可以用，那么甲乙丙三个人都可以骑，同时骑，也就相当与出现了三辆，谁的骑坏了都与别人的没关系。
为了更好更快的完成人物，甲乙丙三人都可以同时拉剩下的人帮忙，比如丁，也会变成三个人，每个丁分身都与其他分身无关。
好吧，不闲扯了，代码也不多贴，把我总结的规律直接写出来吧。
（一）首先要弄明白变量的作用域这个问题：在按键里，有这些规律：1.在主体代码最前面（最好这么干，你非要在中间写一句dim，我也没办法）用dim定义的变量（统称外部变量），作用范围为全脚本，但是如果在子程序里面出现用dim显式定义的同名变量或者在子程序参数列表里的同名变量，那么在该子程序体内所用到的该变量，是内部变量，与外部变量无关；2.子程序中可以用dim关键字定义内部变量，如果未定义的变量直接使用，默认为外部变量。
3.外部变量如果出现在子程序中，并且子程序中没有定义过同名的内部变量，在正常的调用中，按外部变量处理，但是如果在多线程中调用这个子程序，那么该变量会自动变成内部变量初始化掉，具体情况如下：1.Dim a //此处是否定义对多线程内部的变量a无影响2.BeginThread cd3.Sub cd4. Dim a5. //此处如果定义了，变量a为子程序cd的内部变量，6. //否则如果此处为定义，且子程序cs中未定义，则变量a为整个多线程的外部变量7. a = 238. Call cs(a)9. TracePrint a10. Call cs(a)11. TracePrint a12.End Sub13.Sub cs(b)14. Dim a15. //此处如果定义了，变量a在子程序cs内部永远都是内部变量16. //或者把b改成a，也是隐式的定义了一个内部变量a17. a=a+b18.End Sub复制代码4.在主题代码最前面用Global定义的是全局变量，作用范围多说同DimEnv环境变量，我猜这两个有一个可以在脚本之间交换数据。
如果只是用于单脚本的多线程，可以看成一样的。