diff --git a/src/raw.rs b/src/raw.rs
index ed3ee97..89d7878 100644
--- a/src/raw.rs
+++ b/src/raw.rs
@@ -31,7 +31,7 @@
     pub(crate) destroy: unsafe fn(*const ()),
 
     /// Runs the task.
-    pub(crate) run: unsafe fn(*const ()),
+    pub(crate) run: unsafe fn(*const ()) -> bool,
 
     /// Creates a new waker associated with the task.
     pub(crate) clone_waker: unsafe fn(ptr: *const ()) -> RawWaker,
@@ -457,7 +457,7 @@
     ///
     /// If polling its future panics, the task will be closed and the panic will be propagated into
     /// the caller.
-    unsafe fn run(ptr: *const ()) {
+    unsafe fn run(ptr: *const ()) -> bool {
         let raw = Self::from_ptr(ptr);
 
         // Create a context from the raw task pointer and the vtable inside the its header.
@@ -480,7 +480,7 @@
 
                 // Drop the task reference.
                 Self::drop_task(ptr);
-                return;
+                return false;
             }
 
             // Mark the task as unscheduled and running.
@@ -587,6 +587,7 @@
                                 // The thread that woke the task up didn't reschedule it because
                                 // it was running so now it's our responsibility to do so.
                                 Self::schedule(ptr);
+                                return true;
                             } else {
                                 // Drop the task reference.
                                 Self::drop_task(ptr);
@@ -599,6 +600,8 @@
             }
         }
 
+        return false;
+
         /// A guard that closes the task if polling its future panics.
         struct Guard<F, R, S, T>(RawTask<F, R, S, T>)
         where
diff --git a/src/task.rs b/src/task.rs
index 8ef209c..c212f3b 100644
--- a/src/task.rs
+++ b/src/task.rs
@@ -217,6 +217,9 @@
 
     /// Runs the task.
     ///
+    /// Returns `true` if the task was woken while running, in which case it gets rescheduled at
+    /// the end of this method invocation.
+    ///
     /// This method polls the task's future. If the future completes, its result will become
     /// available to the [`JoinHandle`]. And if the future is still pending, the task will have to
     /// be woken up in order to be rescheduled and run again.
@@ -230,13 +233,13 @@
     ///
     /// [`JoinHandle`]: struct.JoinHandle.html
     /// [`catch_unwind`]: https://doc.rust-lang.org/std/panic/fn.catch_unwind.html
-    pub fn run(self) {
+    pub fn run(self) -> bool {
         let ptr = self.raw_task.as_ptr();
         let header = ptr as *const Header;
         mem::forget(self);
 
         unsafe {
-            ((*header).vtable.run)(ptr);
+            ((*header).vtable.run)(ptr)
         }
     }