问题描述
1、读取两个串口的信息的到达时间，会发现时间越拉越大
问题原因
![![[Pasted image 20240910104624.png]]](https://i-blog.csdnimg.cn/direct/97de912afed24ac5bd01128131514076.png)
缺失了主线程的一个循环，如果缺失了这个主循环，会导致两个线程抢占资源，导致线程调度出现问题，一个线程长时间调用
知识点补充
thread1.join()的含义
在 Python 中，thread1.join() 是一个方法调用，它的作用是让当前线程（通常是主线程）等待 thread1 线程执行完成，然后再继续执行接下来的代码。
具体来说，thread1.join() 的含义是当前线程（通常是主线程）会阻塞，直到 thread1 线程执行完毕。这种方法通常用于确保在主线程继续执行之前，thread1 线程的任务已经完成。这对于需要等待子线程完成某些任务后再进行后续操作的情况非常有用，特别是在多线程编程中。
在使用 join() 方法时，可以指定一个超时时间，例如 thread1.join(timeout)，其中 timeout 是等待的最大时间（以秒为单位）。如果超过指定的超时时间，join() 方法会返回，即使 thread1 线程还没有执行完毕。
join的原理
join() 的原理在于它通过让调用它的线程进入阻塞状态，直到目标线程（即被 join() 调用的线程）执行完成。具体而言，它依赖于操作系统和线程库的内部机制来管理线程的生命周期和调度。
详细原理：
-
线程状态管理：
- 当你启动一个线程（例如
thread1.start()），这个线程会独立于主线程或其他线程运行。操作系统管理线程的调度。 - 当你调用
thread1.join()时，调用join()的线程会进入阻塞状态，即暂停当前的执行，等待thread1线程结束。
- 当你启动一个线程（例如
-
阻塞等待机制：
join()内部使用了一种阻塞等待机制，通常是通过条件变量（Condition Variable）或信号量（Semaphore）实现的。这是一种线程间同步机制。- 当
thread1线程完成后，它会通知操作系统，表明它的执行已经结束。thread1.join()内部的条件变量会接收到这个信号，解除阻塞状态，从而允许调用join()的线程继续执行。
-
线程退出标识：
- 每个线程都有一个状态，比如「正在运行」、「已经完成」。当
thread1执行完毕，它会进入「终止」状态。 join()的作用是检查目标线程（如thread1）是否已经完成，如果未完成则等待，直到该线程进入终止状态。
- 每个线程都有一个状态，比如「正在运行」、「已经完成」。当
-
超时机制（可选）：
- 如果使用了
join(timeout)，则主线程会等待目标线程指定的超时时间。如果目标线程在超时时间内结束，主线程会立即解除阻塞；如果目标线程没有结束，join()方法会返回，主线程继续执行，不再等待目标线程。
- 如果使用了
总结
join() 的原理本质是线程同步：它使一个线程等待另一个线程的执行完成。这种同步机制通常依赖于底层操作系统的线程调度和同步原语（如条件变量或信号量），从而实现线程间的协作与管理。
问题解决
偶然解决
在想要给主进程加上一个强制退出机制的时候发现的
在主线程中加入一个while True:time.sleep(1)
防止主线程退出，同时也能防止线程阻塞
# 创建并启动线程
thread1 = threading.Thread(target=self.payload_to_messages, args=(read_payload_func1, self.messages1))
thread2 = threading.Thread(target=self.payload_to_messages, args=(read_payload_func2, self.messages2))
thread3 = threading.Thread(target=self.compareTime)
thread1.start()
thread2.start()
thread3.start()
# 使用非阻塞轮询代替阻塞的 join()try:
while not self.stop_event.is_set():
time.sleep(0.5) # 轮询间隔
except KeyboardInterrupt:
self.stop_event.set() # 捕捉到 Ctrl+C，停止所有线程
thread1.join()
thread2.join()
thread3.join()
serial_port1.close()
serial_port2.close()
# 使用非阻塞轮询代替阻塞的 join()try:
while not self.stop_event.is_set():
time.sleep(0.5) # 轮询间隔
except KeyboardInterrupt:
self.stop_event.set() # 捕捉到 Ctrl+C，停止所有线程
复盘
为什么加上了一个循环sleep两个子线程就不发生资源抢占导致一个线程长时间获取不到资源？
回答：
在你提供的代码中，通过将阻塞的 join() 调用替换为非阻塞轮询的方式，可能减少了某些资源争用问题。以下是这种改动如何减少资源抢占导致线程长时间获取不到资源的原因：
1. 非阻塞轮询 vs 阻塞 join():
- 阻塞的
join()：当你调用thread1.join()时，主线程会完全阻塞，直到thread1结束为止。此时，主线程无法做任何事情，也无法检查和处理其他线程的状态。 - 非阻塞轮询：你通过
while not self.stop_event.is_set():结合time.sleep(0.5)来定期检查线程是否应该继续运行或是否应该终止。这种方式允许主线程周期性地让出 CPU，给其他线程执行的机会，同时不会长时间阻塞在join()上。
2. 减少资源抢占的原因：
通过非阻塞轮询和定期的 time.sleep()，主线程会频繁地让出 CPU 时间片，这样会减少由于某个线程独占资源（如 CPU、内存锁、文件句柄等）时间过长的问题。具体原因包括：
-
线程调度更公平：轮询期间
time.sleep()让主线程进入休眠状态，这让操作系统的线程调度器有更多机会切换到其他线程（如thread1和thread2）。相比于完全阻塞的join()，这种方式更灵活，使线程之间的 CPU 调度更加公平。 -
降低竞争：因为线程之间资源争用可能通过短暂的睡眠得到缓解，系统能够更高效地分配资源给多个线程执行任务，减少某个线程长时间得不到执行机会的可能性。
-
响应性提高：你还通过
self.stop_event提供了中断机制，当捕获KeyboardInterrupt时，所有线程会尽快停止。这种设计也避免了某些线程长时间执行而无法及时停止的情况。
3. 线程任务的性质：
你提到的线程分别执行不同的任务：
thread1和thread2可能是从某个接口或设备读取数据（通过payload_to_messages），而这种读取操作通常涉及 I/O 操作。- I/O 操作一般会主动让出 CPU（即 I/O 线程会等待硬件响应），这使得 CPU 有机会处理其他线程。
因为 thread1 和 thread2 可能涉及 I/O 操作，非阻塞轮询和短暂的 sleep() 可以为 I/O 线程提供更多的时间片，减少资源锁竞争和抢占。
总结
通过使用非阻塞轮询和**time.sleep()**，你给系统提供了更多的调度机会，减少了线程之间由于长时间占用 CPU 或资源锁导致的资源抢占问题。这种方法可以使多线程程序更均衡地分配 CPU 资源，避免某些线程长时间无法获取资源的情况。
线程调度更公平：轮询期间 time.sleep() 让主线程进入休眠状态，这让操作系统的线程调度器有更多机会切换到其他线程（如 thread1 和 thread2）。相比于完全阻塞的 join()，这种方式更灵活，使线程之间的 CPU 调度更加公平。 这是为什么什么原理？
线程调度的“公平性”是指操作系统（OS）在多个线程之间合理分配 CPU 时间，以避免某个线程长时间独占 CPU 资源。time.sleep() 的使用在这个过程中扮演了关键角色，原因如下：
1. 线程调度的基本原理：
操作系统采用线程调度器（scheduler）来管理线程的执行。常见的调度策略有 抢占式调度 和 协作式调度：
- 抢占式调度：操作系统强制性地将 CPU 从一个线程切换到另一个线程，确保每个线程都有机会执行。这种方式常用于多任务操作系统中（如 Linux、Windows 等）。
- 协作式调度：线程主动让出 CPU，调度器将 CPU 分配给其他线程。
当一个线程长时间占用 CPU 而不主动让出时，其他线程可能需要等待较长时间，导致资源竞争和执行延迟。
2. time.sleep() 如何影响调度：
time.sleep() 是一种显式的、主动的方式来让当前线程进入休眠状态（也称为“阻塞”状态）。这会释放 CPU 给其他线程。具体工作原理如下：
- 当一个线程调用
time.sleep()，它告诉操作系统：“我不需要 CPU 资源了，在指定的时间内不调度我。” - 操作系统看到这个线程进入休眠状态，会把它从运行队列中移除，并将 CPU 资源分配给其他就绪的线程（如
thread1和thread2）。 - 这样就给了其他线程更多的执行机会，特别是那些可能正在等待 CPU 时间片的线程。
3. join() 的区别：
-
join()是阻塞的：当你调用thread1.join()时，调用线程（如主线程）会被完全阻塞，直到thread1执行完毕。在这种情况下，主线程不会主动让出 CPU。操作系统依然可以调度其他线程，但主线程的 CPU 时间片可能没有被充分利用。 -
time.sleep()的主动让步：相比之下，time.sleep()主动告诉操作系统，当前线程无需 CPU，可以更快地将时间片分配给其他线程（如正在工作的thread1和thread2），从而使得整个系统的线程调度更加高效和公平。
4. 减少线程“饥饿”：
- 线程饥饿：如果一个线程长时间无法获得 CPU，它就会处于“饥饿”状态，无法完成任务。
time.sleep()的作用：通过定期的sleep()，主线程主动进入等待状态，给其他线程更多的机会来获取 CPU，从而减少某些线程由于资源争用而陷入“饥饿”的情况。
5. 调度公平性的改进：
通过使用 time.sleep()：
- 主线程让出 CPU，减少了对资源的竞争，操作系统能够公平调度其他工作线程。
- 每个线程都能更好地获得 CPU 时间片，尤其是在 I/O 密集型或计算密集型任务时，避免某些线程长时间未被调度。
总结：
time.sleep() 的作用是主动让出 CPU，这让操作系统有更多机会调度其他线程执行。这种机制提高了线程之间的公平性，因为每个线程在争用 CPU 时都能更平等地获得执行机会，减少了某些线程因过多抢占资源而导致其他线程执行不畅的问题。相比完全阻塞的 join()，它使得 CPU 的利用更加灵活高效。
为什么主线程sleep之后，子线程会被公平的线程调度，而join时就不会被公平的线程调度？
当主线程调用 sleep() 时，子线程的线程调度变得更加公平，这与操作系统的调度策略和 join() 的行为方式有直接关系。下面我来解释其中的原因：
1. 主线程的 sleep() 行为：
当主线程调用 time.sleep()，它会主动放弃当前的 CPU 时间片，进入休眠状态，告诉操作系统在指定的时间内不要调度它。这时操作系统的线程调度器可以选择运行其他线程（例如你的子线程），从而使得子线程有更多机会获得 CPU 资源。这是因为：
-
sleep()让出 CPU：当主线程进入休眠，它被暂时移出了 CPU 的就绪队列，操作系统会寻找其他就绪状态的线程来执行。如果有其他线程处于就绪状态（如thread1和thread2），这些线程会被调度器调度执行。 -
轮转时间片机制：许多操作系统使用时间片轮转调度（如 Linux 的 CFS 调度器），通过让线程轮流使用 CPU 时间片，保证每个线程都有机会被调度。主线程休眠时，子线程在就绪队列中，它们可以更频繁地被选中执行。
因此，主线程的 sleep() 调用增加了其他线程被调度的概率，子线程会更加“公平”地获得 CPU 资源。
2. join() 的阻塞行为：
join() 的行为和 sleep() 完全不同。调用 thread1.join() 时，主线程会完全阻塞，直到 thread1 完成。与 sleep() 不同，join() 不会主动释放 CPU 时间片。以下是阻塞时发生的情况：
-
主线程仍可能占用 CPU：虽然主线程在
join()上被阻塞，但这并不意味着操作系统会主动把它放入休眠状态（像sleep()一样）。而是操作系统可能继续把主线程放在就绪队列中，并根据调度策略为它保留 CPU 时间片，等待thread1完成。这意味着主线程仍可能竞争 CPU 资源，即使它没有在执行任务。 -
主线程阻塞但不休眠：当主线程在
join()上等待时，操作系统仍会认为它是一个需要调度的线程，因此主线程可能会周期性地占用 CPU，即使它在join()上什么也不做。而sleep()是明确的休眠操作，主线程会彻底从 CPU 调度中暂时移除。 -
子线程可能无法及时获取 CPU：由于主线程在
join()上阻塞，但没有完全释放 CPU 时间片，这可能导致子线程在 CPU 资源争用中没有足够机会被调度，尤其是在多线程竞争激烈时。
3. 线程调度的操作系统层面差异：
-
time.sleep()是显式让出 CPU：当主线程调用sleep()时，它明确地告诉操作系统：“我不需要 CPU 了，把资源给其他线程。” 这样操作系统会更倾向于调度其他线程（子线程）来利用这段时间。而在join()阻塞时，虽然主线程实际上没在执行任务，但操作系统不一定立即调度其他线程，可能还在处理主线程的阻塞等待。 -
join()等待特定线程结束：在主线程调用join()时，它关注的重点是等待特定子线程的结束，而不是主动让出 CPU 时间。子线程可能由于系统资源竞争等原因需要很长时间才能完成，导致阻塞时间变长，进而影响其他线程的调度。
4. 线程调度不完全公平：
操作系统的线程调度并非完全“公平”，尤其是当线程的优先级、系统负载和线程的运行状态各不相同时。time.sleep() 通过显式地让出 CPU，增加了子线程的调度机会；而 join() 则是主线程被阻塞等待某个特定线程结束，可能导致调度器在实际调度过程中表现得不那么“公平”。
结论：
time.sleep()主动让出 CPU，操作系统调度器会更加积极地分配 CPU 资源给其他就绪线程（子线程），使调度更加公平。join()阻塞时，主线程并没有主动释放 CPU 资源，操作系统可能仍为它分配时间片，这可能减少子线程被调度的机会，从而导致子线程在资源竞争中的劣势。
因此，sleep() 更加有利于多线程环境下的公平调度，而 join() 在某些情况下可能导致资源竞争不平衡，尤其是在高并发或系统负载较大的情况下。
扫一扫
1594
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
