@@ -970,30 +970,23 @@ mod _socket {
         where
             F: FnMut() -> io::Result<R>,
         {
-            let timeout = self.get_timeout().ok();
-            self.sock_op_timeout_err(vm, wait_kind, timeout, f)
+            let deadline = self.get_timeout().ok().map(Deadline::new);
+            self.sock_op_timeout_err(vm, wait_kind, deadline, f)
         }
 
         fn sock_op_timeout_err<F, R>(
             &self,
             vm: &VirtualMachine,
             wait_kind: SockWaitKind,
-            timeout: Option<Duration>,
+            deadline: Option<Deadline>,
             mut f: F,
         ) -> Result<R, IoOrPyException>
         where
             F: FnMut() -> io::Result<R>,
         {
-            // Start the deadline after the first snapshot, so lock/scheduling
-            // delay is not subtracted from a short timeout before poll.
-            let mut deadline = None;
-
             loop {
-                if timeout.is_some() || matches!(wait_kind, SockWaitKind::Connect) {
+                if deadline.is_some() || matches!(wait_kind, SockWaitKind::Connect) {
                     let sock = self.sock_snapshot()?;
-                    if deadline.is_none() {
-                        deadline = timeout.map(Deadline::new);
-                    }
                     sock_wait_deadline(&sock, wait_kind, deadline.as_ref(), vm)?;
                 }
 
@@ -1006,7 +999,7 @@ mod _socket {
                         Err(e) => break e,
                     }
                 };
-                if timeout.is_some() && err.kind() == io::ErrorKind::WouldBlock {
+                if deadline.is_some() && err.kind() == io::ErrorKind::WouldBlock {
                     continue;
                 }
                 return Err(err.into());
@@ -1732,8 +1725,7 @@ mod _socket {
             let mut buf_offset = 0;
             // now we have like 3 layers of interrupt loop :)
             while buf_offset < buf.len() {
-                let interval = deadline.as_ref().map(|d| d.time_until()).transpose()?;
-                self.sock_op_timeout_err(vm, SockWaitKind::Write, interval, || {
+                self.sock_op_timeout_err(vm, SockWaitKind::Write, deadline, || {
                     let subbuf = &buf[buf_offset..];
                     buf_offset += self.sock_snapshot()?.send_with_flags(subbuf, flags)?;
                     Ok(())
@@ -3043,6 +3035,7 @@ mod _socket {
         vm.new_os_subtype_error(timeout(vm), None, msg)
     }
 
+    #[derive(Copy, Clone)]
     pub(crate) struct Deadline {
         deadline: Instant,
     }
@@ -3056,12 +3049,6 @@ mod _socket {
         fn instant(&self) -> Instant {
             self.deadline
         }
-        fn time_until(&self) -> Result<Duration, IoOrPyException> {
-            self.deadline
-                .checked_duration_since(Instant::now())
-                // past the deadline already
-                .ok_or(IoOrPyException::Timeout)
-        }
     }
 
     static DEFAULT_TIMEOUT: AtomicCell<f64> = AtomicCell::new(-1.0);
 
@@ -1851,6 +1851,30 @@ for _ in range(40):
         worker.join().expect("worker panicked");
     }
 
+    /// Per-thread `stop_requested` must trip the eval breaker even when the
+    /// process-wide `STOP_BIT` is clear.
+    #[cfg(feature = "threading")]
+    #[test]
+    fn eval_breaker_tripped_when_stop_requested_and_stop_bit_clear() {
+        let interp = Interpreter::without_stdlib(Default::default());
+        interp.enter(|vm| {
+            crate::signal::clear_stop_bit();
+            assert!(
+                crate::vm::thread::set_stop_requested_for_current_thread(true),
+                "current thread has no stop_requested flag"
+            );
+            crate::signal::clear_stop_bit();
+            let pending = crate::signal::eval_breaker_pending();
+            let tripped = vm.eval_breaker_tripped();
+            crate::vm::thread::set_stop_requested_for_current_thread(false);
+            assert!(
+                !pending,
+                "STOP_BIT or another process-wide breaker bit was set"
+            );
+            assert!(tripped);
+        });
+    }
+
     /// Entering a subinterpreter from inside the parent's `enter` must attach
     /// the subinterpreter's thread slot (and detach the parent's). Otherwise the
     /// thread runs the sub's bytecode with a DETACHED slot, and a collector
 
@@ -892,6 +892,19 @@ pub fn stop_requested_for_current_thread() -> bool {
     })
 }
 
+#[cfg(all(test, feature = "threading"))]
+pub(crate) fn set_stop_requested_for_current_thread(value: bool) -> bool {
+    CURRENT_STOP_REQUESTED.with(|cached| {
+        let flag = cached.get();
+        if flag.is_null() {
+            return false;
+        }
+        // SAFETY: same lifetime as `stop_requested_for_current_thread`.
+        unsafe { &*flag }.store(value, Ordering::Release);
+        true
+    })
+}
+
 /// Whether the QSBR subsystem asked this thread to pass a checkpoint.
 /// A missed or racing read of this flag is harmless: the pending
 /// retirement is still processed at the next checkpoint or by the GC