Implemented dispatcher that works like WPF one

Avalonia.Desktop.slnf

@@ -8,9 +8,9 @@
       "samples\\GpuInterop\\GpuInterop.csproj",
       "samples\\IntegrationTestApp\\IntegrationTestApp.csproj",
       "samples\\MiniMvvm\\MiniMvvm.csproj",
+      "samples\\ReactiveUIDemo\\ReactiveUIDemo.csproj",
       "samples\\SampleControls\\ControlSamples.csproj",
       "samples\\Sandbox\\Sandbox.csproj",
-      "samples\\ReactiveUIDemo\\ReactiveUIDemo.csproj",
       "src\\Avalonia.Base\\Avalonia.Base.csproj",
       "src\\Avalonia.Build.Tasks\\Avalonia.Build.Tasks.csproj",
       "src\\Avalonia.Controls.ColorPicker\\Avalonia.Controls.ColorPicker.csproj",
@@ -38,12 +38,13 @@
       "src\\Markup\\Avalonia.Markup.Xaml\\Avalonia.Markup.Xaml.csproj",
       "src\\Markup\\Avalonia.Markup\\Avalonia.Markup.csproj",
       "src\\Skia\\Avalonia.Skia\\Avalonia.Skia.csproj",
-      "src\\Windows\\Avalonia.Direct2D1\\Avalonia.Direct2D1.csproj",
-      "src\\Windows\\Avalonia.Win32.Interop\\Avalonia.Win32.Interop.csproj",
-      "src\\Windows\\Avalonia.Win32\\Avalonia.Win32.csproj",
+      "src\\tools\\Avalonia.Generators\\Avalonia.Generators.csproj",
       "src\\tools\\DevAnalyzers\\DevAnalyzers.csproj",
       "src\\tools\\DevGenerators\\DevGenerators.csproj",
       "src\\tools\\PublicAnalyzers\\Avalonia.Analyzers.csproj",
+      "src\\Windows\\Avalonia.Direct2D1\\Avalonia.Direct2D1.csproj",
+      "src\\Windows\\Avalonia.Win32.Interop\\Avalonia.Win32.Interop.csproj",
+      "src\\Windows\\Avalonia.Win32\\Avalonia.Win32.csproj",
       "tests\\Avalonia.Base.UnitTests\\Avalonia.Base.UnitTests.csproj",
       "tests\\Avalonia.Benchmarks\\Avalonia.Benchmarks.csproj",
       "tests\\Avalonia.Controls.DataGrid.UnitTests\\Avalonia.Controls.DataGrid.UnitTests.csproj",
@@ -63,4 +64,4 @@
       "tests\\Avalonia.UnitTests\\Avalonia.UnitTests.csproj"
     ]
   }
-}
+}

native/Avalonia.Native/src/OSX/platformthreading.mm

@@ -1,193 +1,235 @@
 #include "common.h"
 
 class PlatformThreadingInterface;
+
+
+class LoopCancellation : public ComSingleObject<IAvnLoopCancellation, &IID_IAvnLoopCancellation>
+{
+public:
+    FORWARD_IUNKNOWN()
+    
+    bool Running = false;
+    bool Cancelled = false;
+    bool IsApp = false;
+
+    virtual void Cancel() override
+    {
+        Cancelled = true;
+        if(Running)
+        {
+            Running = false;
+            if(![NSThread isMainThread])
+            {
+                AddRef();
+                dispatch_async(dispatch_get_main_queue(), ^{
+                    if(Release() == 0)
+                        return;
+                    Cancel();
+                });
+                return;
+            };
+            if(IsApp)
+                [NSApp stop:nil];
+            else
+            {
+                // Wakeup the event loop
+                NSEvent* event = [NSEvent otherEventWithType:NSEventTypeApplicationDefined
+                                                    location:NSMakePoint(0, 0)
+                                               modifierFlags:0
+                                                   timestamp:0
+                                                windowNumber:0
+                                                     context:nil
+                                                     subtype:0
+                                                       data1:0
+                                                       data2:0];
+                [NSApp postEvent:event atStart:YES];
+            }
+        }
+    };
+};
+
+// CFRunLoopTimerSetNextFireDate docs recommend to "create a repeating timer with an initial
+// firing time in the distant future (or the initial firing time) and a very large repeat
+// interval—on the order of decades or more"
+static double distantFutureInterval = (double)50*365*24*3600;
+
 @interface Signaler : NSObject
--(void) setParent: (PlatformThreadingInterface*)parent;
--(void) signal: (int) priority;
+-(void) setEvents:(IAvnPlatformThreadingInterfaceEvents*) events;
+-(void) updateTimer:(int)ms;
 -(Signaler*) init;
+-(void) destroyObserver;
+-(void) signal;
 @end
 
-@implementation ActionCallback
+@implementation Signaler
 {
-    ComPtr<IAvnActionCallback> _callback;
-
+    ComPtr<IAvnPlatformThreadingInterfaceEvents> _events;
+    bool _wakeupDelegateSent;
+    bool _signaled;
+    CFRunLoopObserverRef _observer;
+    CFRunLoopTimerRef _timer;
 }
-- (ActionCallback*) initWithCallback: (IAvnActionCallback*) callback
+
+- (Signaler*) init
 {
-    _callback = callback;
+    _observer = CFRunLoopObserverCreateWithHandler(nil,
+                                                   kCFRunLoopBeforeSources | kCFRunLoopAfterWaiting,
+                                                   true, 0,
+                                                   ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) {
+        bool signaled;
+        @synchronized (self) {
+            signaled = self->_signaled;
+        }
+        if(signaled)
+        {
+            self->_events->Signaled();
+            @synchronized (self) {
+                self->_signaled = false;
+            }
+        }
+    });
+    CFRunLoopAddObserver(CFRunLoopGetMain(), _observer, kCFRunLoopCommonModes);
+    
+    
+    _timer = CFRunLoopTimerCreateWithHandler(nil, CFAbsoluteTimeGetCurrent() + distantFutureInterval, distantFutureInterval, 0, 0, ^(CFRunLoopTimerRef timer) {
+        self->_events->Timer();
+    });
+    
+    CFRunLoopAddTimer(CFRunLoopGetMain(), _timer, kCFRunLoopCommonModes);
+    
     return self;
 }
 
-- (void) action
+- (void) destroyObserver
 {
-    _callback->Run();
+    if(_observer != nil)
+    {
+        CFRunLoopObserverInvalidate(_observer);
+        CFRelease(_observer);
+        _observer = nil;
+    }
+    
+    if(_timer != nil)
+    {
+        CFRunLoopTimerInvalidate(_timer);
+        CFRelease(_timer);
+        _timer = nil;
+    }
 }
 
+-(void) updateTimer:(int)ms
+{
+    if(_timer == nil)
+        return;
+    double interval = ms < 0 ? distantFutureInterval : ((double)ms / 1000);
+    CFRunLoopTimerSetTolerance(_timer, 0);
+    CFRunLoopTimerSetNextFireDate(_timer, CFAbsoluteTimeGetCurrent() + interval);
+}
 
-@end
+- (void) setEvents: (IAvnPlatformThreadingInterfaceEvents*) events
+{
+    _events = events;
+}
 
-class TimerWrapper : public ComUnknownObject
+- (void) signal
 {
-    NSTimer* _timer;
-public:
-    TimerWrapper(IAvnActionCallback* callback, int ms)
-    {
-        auto cb = [[ActionCallback alloc] initWithCallback:callback];
-        _timer = [NSTimer scheduledTimerWithTimeInterval:(NSTimeInterval)(double)ms/1000 target:cb selector:@selector(action) userInfo:nullptr repeats:true];
-    }
-                  
-    virtual ~TimerWrapper()
-    {
-         [_timer invalidate];
+    @synchronized (self) {
+        if(_signaled)
+            return;
+        _signaled = true;
+        CFRunLoopWakeUp(CFRunLoopGetMain());
     }
-};
+}
 
+@end
 
 
 class PlatformThreadingInterface : public ComSingleObject<IAvnPlatformThreadingInterface, &IID_IAvnPlatformThreadingInterface>
 {
 private:
+    ComPtr<IAvnPlatformThreadingInterfaceEvents> _events;
     Signaler* _signaler;
-    bool _wasRunningAtLeastOnce = false;
-    
-    class LoopCancellation : public ComSingleObject<IAvnLoopCancellation, &IID_IAvnLoopCancellation>
-    {
-    public:
-        FORWARD_IUNKNOWN()
-        
-        bool Running = false;
-        bool Cancelled = false;
-        
-        virtual void Cancel() override
-        {
-            Cancelled = true;
-            if(Running)
-            {
-                Running = false;
-                dispatch_async(dispatch_get_main_queue(), ^{
-                    [[NSApplication sharedApplication] stop:nil];
-                    NSEvent* event = [NSEvent otherEventWithType:NSEventTypeApplicationDefined
-                                                        location:NSMakePoint(0, 0)
-                                                   modifierFlags:0
-                                                       timestamp:0
-                                                    windowNumber:0
-                                                         context:nil
-                                                         subtype:0
-                                                           data1:0
-                                                           data2:0];
-                    [NSApp postEvent:event atStart:YES];
-                });
-            }
-        }
-
-    };
-    
+    CFRunLoopObserverRef _observer = nil;
 public:
     FORWARD_IUNKNOWN()
-    ComPtr<IAvnSignaledCallback> SignaledCallback;
-
     PlatformThreadingInterface()
     {
         _signaler = [Signaler new];
-        [_signaler setParent:this];
-    }
+    };
     
     ~PlatformThreadingInterface()
     {
-        if(_signaler)
-            [_signaler setParent: NULL];
-        _signaler = NULL;
+        [_signaler destroyObserver];
     }
     
-    virtual bool GetCurrentThreadIsLoopThread() override
+    bool GetCurrentThreadIsLoopThread() override
     {
         return [NSThread isMainThread];
-    }
-    virtual void SetSignaledCallback(IAvnSignaledCallback* cb) override
+    };
+    
+    bool HasPendingInput() override
     {
-        SignaledCallback = cb;
-    }
-    virtual IAvnLoopCancellation* CreateLoopCancellation() override
+        auto event = [NSApp
+                      nextEventMatchingMask: NSEventMaskAny
+                      untilDate:nil
+                      inMode:NSDefaultRunLoopMode
+                      dequeue:false];
+        return event != nil;
+    };
+    
+    void SetEvents(IAvnPlatformThreadingInterfaceEvents *cb) override
+    {
+        _events = cb;
+        [_signaler setEvents:cb];
+    };
+    
+    IAvnLoopCancellation *CreateLoopCancellation() override
     {
         return new LoopCancellation();
-    }
+    };
     
-    virtual HRESULT RunLoop(IAvnLoopCancellation* cancel) override
+    void RunLoop(IAvnLoopCancellation *cancel) override
     {
         START_COM_CALL;
-        
         auto can = dynamic_cast<LoopCancellation*>(cancel);
         if(can->Cancelled)
-            return S_OK;
-        if(_wasRunningAtLeastOnce)
-            return E_FAIL;
+            return;
         can->Running = true;
-        _wasRunningAtLeastOnce = true;
-        [NSApp run];
-        return S_OK;
-    }
+        if(![NSApp isRunning])
+        {
+            can->IsApp = true;
+            [NSApp run];
+            return;
+        }
+        else
+        {
+            while(!can->Cancelled)
+            {
+                @autoreleasepool
+                {
+                    NSEvent* ev = [NSApp
+                                   nextEventMatchingMask:NSEventMaskAny
+                                   untilDate: [NSDate dateWithTimeIntervalSinceNow:1]
+                                   inMode:NSDefaultRunLoopMode
+                                   dequeue:true];
+                    if(ev != NULL)
+                        [NSApp sendEvent:ev];
+                }
+            }
+        }
+    };
     
-    virtual void Signal(int priority) override
+    void Signal() override
     {
-        [_signaler signal:priority];
-    }
+        [_signaler signal];
+    };
     
-    virtual IUnknown* StartTimer(int priority, int ms, IAvnActionCallback* callback) override
+    void UpdateTimer(int ms) override
     {
-        @autoreleasepool {
-            
-            return new TimerWrapper(callback, ms);
-        }
-    }
-};
-
-@implementation Signaler
-
-PlatformThreadingInterface* _parent = 0;
-bool _signaled = 0;
-NSArray<NSString*>* _modes;
-
--(Signaler*) init
-{
-    if(self = [super init])
-    {
-        _modes = [NSArray arrayWithObjects: NSDefaultRunLoopMode, NSEventTrackingRunLoopMode, NSModalPanelRunLoopMode, NSRunLoopCommonModes, NSConnectionReplyMode, nil];
-    }
-    return self;
-}
-
--(void) perform
-{
-    ComPtr<IAvnSignaledCallback> cb;
-    @synchronized (self) {
-        _signaled  = false;
-        if(_parent != NULL)
-            cb = _parent->SignaledCallback;
-    }
-    if(cb != nullptr)
-        cb->Signaled(0, false);
-}
-
--(void) setParent:(PlatformThreadingInterface *)parent
-{
-    @synchronized (self) {
-        _parent = parent;
-    }
-}
-
--(void) signal: (int) priority
-{
-
-    @synchronized (self) {
-        if(_signaled)
-            return;
-        _signaled = true;
-        [self performSelector:@selector(perform) onThread:[NSThread mainThread] withObject:NULL waitUntilDone:false modes:_modes];
-    }
+        [_signaler updateTimer:ms];
+    };
     
-}
-@end
-
+};
 
 extern IAvnPlatformThreadingInterface* CreatePlatformThreading()
 {

src/Avalonia.Base/Threading/AvaloniaSynchronizationContext.cs

@@ -30,7 +30,7 @@ namespace Avalonia.Threading
         /// <inheritdoc/>
         public override void Post(SendOrPostCallback d, object? state)
         {
-           Dispatcher.UIThread.Post(d, state, DispatcherPriority.Background);
+            Dispatcher.UIThread.Post(() => d(state), DispatcherPriority.Background);
         }
 
         /// <inheritdoc/>

src/Avalonia.Base/Threading/Dispatcher.Invoke.cs

@@ -0,0 +1,541 @@
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Threading;
+
+namespace Avalonia.Threading;
+
+public partial class Dispatcher
+{
+    /// <summary>
+    ///     Executes the specified Action synchronously on the thread that
+    ///     the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     An Action delegate to invoke through the dispatcher.
+    /// </param>
+    /// <remarks>
+    ///     Note that the default priority is DispatcherPriority.Send.
+    /// </remarks>
+    public void Invoke(Action callback)
+    {
+        Invoke(callback, DispatcherPriority.Send, CancellationToken.None, TimeSpan.FromMilliseconds(-1));
+    }
+
+    /// <summary>
+    ///     Executes the specified Action synchronously on the thread that
+    ///     the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     An Action delegate to invoke through the dispatcher.
+    /// </param>
+    /// <param name="priority">
+    ///     The priority that determines in what order the specified
+    ///     callback is invoked relative to the other pending operations
+    ///     in the Dispatcher.
+    /// </param>
+    public void Invoke(Action callback, DispatcherPriority priority)
+    {
+        Invoke(callback, priority, CancellationToken.None, TimeSpan.FromMilliseconds(-1));
+    }
+
+    /// <summary>
+    ///     Executes the specified Action synchronously on the thread that
+    ///     the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     An Action delegate to invoke through the dispatcher.
+    /// </param>
+    /// <param name="priority">
+    ///     The priority that determines in what order the specified
+    ///     callback is invoked relative to the other pending operations
+    ///     in the Dispatcher.
+    /// </param>
+    /// <param name="cancellationToken">
+    ///     A cancellation token that can be used to cancel the operation.
+    ///     If the operation has not started, it will be aborted when the
+    ///     cancellation token is canceled.  If the operation has started,
+    ///     the operation can cooperate with the cancellation request.
+    /// </param>
+    public void Invoke(Action callback, DispatcherPriority priority, CancellationToken cancellationToken)
+    {
+        Invoke(callback, priority, cancellationToken, TimeSpan.FromMilliseconds(-1));
+    }
+
+    /// <summary>
+    ///     Executes the specified Action synchronously on the thread that
+    ///     the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     An Action delegate to invoke through the dispatcher.
+    /// </param>
+    /// <param name="priority">
+    ///     The priority that determines in what order the specified
+    ///     callback is invoked relative to the other pending operations
+    ///     in the Dispatcher.
+    /// </param>
+    /// <param name="cancellationToken">
+    ///     A cancellation token that can be used to cancel the operation.
+    ///     If the operation has not started, it will be aborted when the
+    ///     cancellation token is canceled.  If the operation has started,
+    ///     the operation can cooperate with the cancellation request.
+    /// </param>
+    /// <param name="timeout">
+    ///     The minimum amount of time to wait for the operation to start.
+    ///     Once the operation has started, it will complete before this method
+    ///     returns.
+    /// </param>
+    public void Invoke(Action callback, DispatcherPriority priority, CancellationToken cancellationToken,
+        TimeSpan timeout)
+    {
+        if (callback == null)
+        {
+            throw new ArgumentNullException("callback");
+        }
+
+        DispatcherPriority.Validate(priority, "priority");
+
+        if (timeout.TotalMilliseconds < 0 &&
+            timeout != TimeSpan.FromMilliseconds(-1))
+        {
+            throw new ArgumentOutOfRangeException("timeout");
+        }
+
+        // Fast-Path: if on the same thread, and invoking at Send priority,
+        // and the cancellation token is not already canceled, then just
+        // call the callback directly.
+        if (!cancellationToken.IsCancellationRequested && priority == DispatcherPriority.Send && CheckAccess())
+        {
+            callback();
+            return;
+        }
+
+        // Slow-Path: go through the queue.
+        DispatcherOperation operation = new DispatcherOperation(this, priority, callback, false);
+        InvokeImpl(operation, cancellationToken, timeout);
+    }
+
+    /// <summary>
+    ///     Executes the specified Func<TResult> synchronously on the
+    ///     thread that the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     A Func<TResult> delegate to invoke through the dispatcher.
+    /// </param>
+    /// <returns>
+    ///     The return value from the delegate being invoked.
+    /// </returns>
+    /// <remarks>
+    ///     Note that the default priority is DispatcherPriority.Send.
+    /// </remarks>
+    public TResult Invoke<TResult>(Func<TResult> callback)
+    {
+        return Invoke(callback, DispatcherPriority.Send, CancellationToken.None, TimeSpan.FromMilliseconds(-1));
+    }
+
+    /// <summary>
+    ///     Executes the specified Func<TResult> synchronously on the
+    ///     thread that the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     A Func<TResult> delegate to invoke through the dispatcher.
+    /// </param>
+    /// <param name="priority">
+    ///     The priority that determines in what order the specified
+    ///     callback is invoked relative to the other pending operations
+    ///     in the Dispatcher.
+    /// </param>
+    /// <returns>
+    ///     The return value from the delegate being invoked.
+    /// </returns>
+    public TResult Invoke<TResult>(Func<TResult> callback, DispatcherPriority priority)
+    {
+        return Invoke(callback, priority, CancellationToken.None, TimeSpan.FromMilliseconds(-1));
+    }
+
+    /// <summary>
+    ///     Executes the specified Func<TResult> synchronously on the
+    ///     thread that the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     A Func<TResult> delegate to invoke through the dispatcher.
+    /// </param>
+    /// <param name="priority">
+    ///     The priority that determines in what order the specified
+    ///     callback is invoked relative to the other pending operations
+    ///     in the Dispatcher.
+    /// </param>
+    /// <param name="cancellationToken">
+    ///     A cancellation token that can be used to cancel the operation.
+    ///     If the operation has not started, it will be aborted when the
+    ///     cancellation token is canceled.  If the operation has started,
+    ///     the operation can cooperate with the cancellation request.
+    /// </param>
+    /// <returns>
+    ///     The return value from the delegate being invoked.
+    /// </returns>
+    public TResult Invoke<TResult>(Func<TResult> callback, DispatcherPriority priority,
+        CancellationToken cancellationToken)
+    {
+        return Invoke(callback, priority, cancellationToken, TimeSpan.FromMilliseconds(-1));
+    }
+
+    /// <summary>
+    ///     Executes the specified Func<TResult> synchronously on the
+    ///     thread that the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     A Func<TResult> delegate to invoke through the dispatcher.
+    /// </param>
+    /// <param name="priority">
+    ///     The priority that determines in what order the specified
+    ///     callback is invoked relative to the other pending operations
+    ///     in the Dispatcher.
+    /// </param>
+    /// <param name="cancellationToken">
+    ///     A cancellation token that can be used to cancel the operation.
+    ///     If the operation has not started, it will be aborted when the
+    ///     cancellation token is canceled.  If the operation has started,
+    ///     the operation can cooperate with the cancellation request.
+    /// </param>
+    /// <param name="timeout">
+    ///     The minimum amount of time to wait for the operation to start.
+    ///     Once the operation has started, it will complete before this method
+    ///     returns.
+    /// </param>
+    /// <returns>
+    ///     The return value from the delegate being invoked.
+    /// </returns>
+    public TResult Invoke<TResult>(Func<TResult> callback, DispatcherPriority priority,
+        CancellationToken cancellationToken, TimeSpan timeout)
+    {
+        if (callback == null)
+        {
+            throw new ArgumentNullException("callback");
+        }
+
+        DispatcherPriority.Validate(priority, "priority");
+
+        if (timeout.TotalMilliseconds < 0 &&
+            timeout != TimeSpan.FromMilliseconds(-1))
+        {
+            throw new ArgumentOutOfRangeException("timeout");
+        }
+
+        // Fast-Path: if on the same thread, and invoking at Send priority,
+        // and the cancellation token is not already canceled, then just
+        // call the callback directly.
+        if (!cancellationToken.IsCancellationRequested && priority == DispatcherPriority.Send && CheckAccess())
+        {
+            return callback();
+        }
+
+        // Slow-Path: go through the queue.
+        DispatcherOperation<TResult> operation = new DispatcherOperation<TResult>(this, priority, callback);
+        return (TResult)InvokeImpl(operation, cancellationToken, timeout)!;
+    }
+
+    /// <summary>
+    ///     Executes the specified Action asynchronously on the thread
+    ///     that the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     An Action delegate to invoke through the dispatcher.
+    /// </param>
+    /// <returns>
+    ///     An operation representing the queued delegate to be invoked.
+    /// </returns>
+    /// <remarks>
+    ///     Note that the default priority is DispatcherPriority.Normal.
+    /// </remarks>
+    public DispatcherOperation InvokeAsync(Action callback)
+    {
+        return InvokeAsync(callback, DispatcherPriority.Normal, CancellationToken.None);
+    }
+
+    /// <summary>
+    ///     Executes the specified Action asynchronously on the thread
+    ///     that the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     An Action delegate to invoke through the dispatcher.
+    /// </param>
+    /// <param name="priority">
+    ///     The priority that determines in what order the specified
+    ///     callback is invoked relative to the other pending operations
+    ///     in the Dispatcher.
+    /// </param>
+    /// <returns>
+    ///     An operation representing the queued delegate to be invoked.
+    /// </returns>
+    /// <returns>
+    ///     An operation representing the queued delegate to be invoked.
+    /// </returns>
+    public DispatcherOperation InvokeAsync(Action callback, DispatcherPriority priority)
+    {
+        return InvokeAsync(callback, priority, CancellationToken.None);
+    }
+
+    /// <summary>
+    ///     Executes the specified Action asynchronously on the thread
+    ///     that the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     An Action delegate to invoke through the dispatcher.
+    /// </param>
+    /// <param name="priority">
+    ///     The priority that determines in what order the specified
+    ///     callback is invoked relative to the other pending operations
+    ///     in the Dispatcher.
+    /// </param>
+    /// <param name="cancellationToken">
+    ///     A cancellation token that can be used to cancel the operation.
+    ///     If the operation has not started, it will be aborted when the
+    ///     cancellation token is canceled.  If the operation has started,
+    ///     the operation can cooperate with the cancellation request.
+    /// </param>
+    /// <returns>
+    ///     An operation representing the queued delegate to be invoked.
+    /// </returns>
+    public DispatcherOperation InvokeAsync(Action callback, DispatcherPriority priority,
+        CancellationToken cancellationToken)
+    {
+        if (callback == null)
+        {
+            throw new ArgumentNullException("callback");
+        }
+
+        DispatcherPriority.Validate(priority, "priority");
+
+        DispatcherOperation operation = new DispatcherOperation(this, priority, callback, false);
+        InvokeAsyncImpl(operation, cancellationToken);
+
+        return operation;
+    }
+
+    /// <summary>
+    ///     Executes the specified Func<TResult> asynchronously on the
+    ///     thread that the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     A Func<TResult> delegate to invoke through the dispatcher.
+    /// </param>
+    /// <returns>
+    ///     An operation representing the queued delegate to be invoked.
+    /// </returns>
+    /// <remarks>
+    ///     Note that the default priority is DispatcherPriority.Normal.
+    /// </remarks>
+    public DispatcherOperation<TResult> InvokeAsync<TResult>(Func<TResult> callback)
+    {
+        return InvokeAsync(callback, DispatcherPriority.Normal, CancellationToken.None);
+    }
+
+    /// <summary>
+    ///     Executes the specified Func<TResult> asynchronously on the
+    ///     thread that the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     A Func<TResult> delegate to invoke through the dispatcher.
+    /// </param>
+    /// <param name="priority">
+    ///     The priority that determines in what order the specified
+    ///     callback is invoked relative to the other pending operations
+    ///     in the Dispatcher.
+    /// </param>
+    /// <returns>
+    ///     An operation representing the queued delegate to be invoked.
+    /// </returns>
+    public DispatcherOperation<TResult> InvokeAsync<TResult>(Func<TResult> callback, DispatcherPriority priority)
+    {
+        return InvokeAsync(callback, priority, CancellationToken.None);
+    }
+
+    /// <summary>
+    ///     Executes the specified Func<TResult> asynchronously on the
+    ///     thread that the Dispatcher was created on.
+    /// </summary>
+    /// <param name="callback">
+    ///     A Func<TResult> delegate to invoke through the dispatcher.
+    /// </param>
+    /// <param name="priority">
+    ///     The priority that determines in what order the specified
+    ///     callback is invoked relative to the other pending operations
+    ///     in the Dispatcher.
+    /// </param>
+    /// <param name="cancellationToken">
+    ///     A cancellation token that can be used to cancel the operation.
+    ///     If the operation has not started, it will be aborted when the
+    ///     cancellation token is canceled.  If the operation has started,
+    ///     the operation can cooperate with the cancellation request.
+    /// </param>
+    /// <returns>
+    ///     An operation representing the queued delegate to be invoked.
+    /// </returns>
+    public DispatcherOperation<TResult> InvokeAsync<TResult>(Func<TResult> callback, DispatcherPriority priority,
+        CancellationToken cancellationToken)
+    {
+        if (callback == null)
+        {
+            throw new ArgumentNullException("callback");
+        }
+
+        DispatcherPriority.Validate(priority, "priority");
+
+        DispatcherOperation<TResult> operation = new DispatcherOperation<TResult>(this, priority, callback);
+        InvokeAsyncImpl(operation, cancellationToken);
+
+        return operation;
+    }
+
+    private void InvokeAsyncImpl(DispatcherOperation operation, CancellationToken cancellationToken)
+    {
+        bool succeeded = false;
+
+        // Could be a non-dispatcher thread, lock to read
+        lock (InstanceLock)
+        {
+            if (!cancellationToken.IsCancellationRequested &&
+                !_hasShutdownFinished &&
+                !Environment.HasShutdownStarted)
+            {
+                // Add the operation to the work queue
+                _queue.Enqueue(operation.Priority, operation);
+
+                // Make sure we will wake up to process this operation.
+                succeeded = RequestProcessing();
+
+                if (!succeeded)
+                {
+                    // Dequeue the item since we failed to request
+                    // processing for it.  Note we will mark it aborted
+                    // below.
+                    _queue.RemoveItem(operation);
+                }
+            }
+        }
+
+        if (succeeded == true)
+        {
+            // We have enqueued the operation.  Register a callback
+            // with the cancellation token to abort the operation
+            // when cancellation is requested.
+            if (cancellationToken.CanBeCanceled)
+            {
+                CancellationTokenRegistration cancellationRegistration =
+                    cancellationToken.Register(s => ((DispatcherOperation)s!).Abort(), operation);
+
+                // Revoke the cancellation when the operation is done.
+                operation.Aborted += (s, e) => cancellationRegistration.Dispose();
+                operation.Completed += (s, e) => cancellationRegistration.Dispose();
+            }
+        }
+        else
+        {
+            // We failed to enqueue the operation, and the caller that
+            // created the operation does not expose it before we return,
+            // so it is safe to modify the operation outside of the lock.
+            // Just mark the operation as aborted, which we can safely
+            // return to the user.
+            operation.DoAbort();
+        }
+    }
+
+
+    private object? InvokeImpl(DispatcherOperation operation, CancellationToken cancellationToken, TimeSpan timeout)
+    {
+        object? result = null;
+
+        Debug.Assert(timeout.TotalMilliseconds >= 0 || timeout == TimeSpan.FromMilliseconds(-1));
+        Debug.Assert(operation.Priority != DispatcherPriority.Send || !CheckAccess()); // should be handled by caller
+
+        if (!cancellationToken.IsCancellationRequested)
+        {
+            // This operation must be queued since it was invoked either to
+            // another thread, or at a priority other than Send.
+            InvokeAsyncImpl(operation, cancellationToken);
+
+            CancellationToken ctTimeout = CancellationToken.None;
+            CancellationTokenRegistration ctTimeoutRegistration = new CancellationTokenRegistration();
+            CancellationTokenSource? ctsTimeout = null;
+
+            if (timeout.TotalMilliseconds >= 0)
+            {
+                // Create a CancellationTokenSource that will abort the
+                // operation after the timeout.  Note that this does not
+                // cancel the operation, just abort it if it is still pending.
+                ctsTimeout = new CancellationTokenSource(timeout);
+                ctTimeout = ctsTimeout.Token;
+                ctTimeoutRegistration = ctTimeout.Register(s => ((DispatcherOperation)s!).Abort(), operation);
+            }
+
+
+            // We have already registered with the cancellation tokens
+            // (both provided by the user, and one for the timeout) to
+            // abort the operation when they are canceled.  If the
+            // operation has already started when the timeout expires,
+            // we still wait for it to complete.  This is different
+            // than simply waiting on the operation with a timeout
+            // because we are the ones queueing the dispatcher
+            // operation, not the caller.  We can't leave the operation
+            // in a state that it might execute if we return that it did not
+            // invoke.
+            try
+            {
+                operation.GetTask().Wait();
+
+                Debug.Assert(operation.Status == DispatcherOperationStatus.Completed ||
+                             operation.Status == DispatcherOperationStatus.Aborted);
+
+                // Old async semantics return from Wait without
+                // throwing an exception if the operation was aborted.
+                // There is no need to test the timout condition, since
+                // the old async semantics would just return the result,
+                // which would be null.
+
+                // This should not block because either the operation
+                // is using the old async sematics, or the operation
+                // completed successfully.
+                result = operation.GetResult();
+            }
+            catch (OperationCanceledException)
+            {
+                Debug.Assert(operation.Status == DispatcherOperationStatus.Aborted);
+
+                // New async semantics will throw an exception if the
+                // operation was aborted.  Here we convert that
+                // exception into a timeout exception if the timeout
+                // has expired (admittedly a weak relationship
+                // assuming causality).
+                if (ctTimeout.IsCancellationRequested)
+                {
+                    // The operation was canceled because of the
+                    // timeout, throw a TimeoutException instead.
+                    throw new TimeoutException();
+                }
+                else
+                {
+                    // The operation was canceled from some other reason.
+                    throw;
+                }
+            }
+            finally
+            {
+                ctTimeoutRegistration.Dispose();
+                if (ctsTimeout != null)
+                {
+                    ctsTimeout.Dispose();
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    public void Post(Action action, DispatcherPriority priority = default)
+    {
+        _ = action ?? throw new ArgumentNullException(nameof(action));
+        InvokeAsyncImpl(new DispatcherOperation(this, priority, action, true), CancellationToken.None);
+    }
+}

src/Avalonia.Base/Threading/Dispatcher.Queue.cs

@@ -0,0 +1,203 @@
+using System;
+using System.Diagnostics;
+
+namespace Avalonia.Threading;
+
+public partial class Dispatcher
+{
+    private readonly DispatcherPriorityQueue _queue = new();
+    private bool _signaled;
+    private DispatcherTimer? _backgroundTimer;
+    private const int MaximumTimeProcessingBackgroundJobs = 50;
+    
+    void RequestBackgroundProcessing()
+    {
+        if (_backgroundTimer == null)
+        {
+            _backgroundTimer =
+                new DispatcherTimer(this, DispatcherPriority.Send,
+                    TimeSpan.FromMilliseconds(1));
+            _backgroundTimer.Tick += delegate
+            {
+                _backgroundTimer.Stop();
+            };
+        }
+
+        _backgroundTimer.IsEnabled = true;
+    }
+
+    /// <summary>
+    /// Force-runs all dispatcher operations ignoring any pending OS events, use with caution
+    /// </summary>
+    public void RunJobs(DispatcherPriority? priority = null)
+    {
+        priority ??= DispatcherPriority.MinimumActiveValue;
+        if (priority < DispatcherPriority.MinimumActiveValue)
+            priority = DispatcherPriority.MinimumActiveValue;
+        while (true)
+        {
+            DispatcherOperation? job;
+            lock (InstanceLock)
+                job = _queue.Peek();
+            if (job == null)
+                return;
+            if (priority != null && job.Priority < priority.Value)
+                return;
+            ExecuteJob(job);
+        }
+    }
+
+    internal static void ResetForUnitTests()
+    {
+        if (s_uiThread == null)
+            return;
+        var st = Stopwatch.StartNew();
+        while (true)
+        {
+            if (st.Elapsed.TotalSeconds > 5)
+                throw new InvalidProgramException("You've caused dispatcher loop");
+            
+            DispatcherOperation? job;
+            lock (s_uiThread.InstanceLock)
+                job = s_uiThread._queue.Peek();
+            if (job == null || job.Priority <= DispatcherPriority.Inactive)
+            {
+                s_uiThread = null;
+                return;
+            }
+
+            s_uiThread.ExecuteJob(job);
+        }
+
+    }
+    
+    private void ExecuteJob(DispatcherOperation job)
+    {
+        lock (InstanceLock)
+            _queue.RemoveItem(job);
+        job.Execute();
+        // The backend might be firing timers with a low priority,
+        // so we manually check if our high priority timers are due for execution
+        PromoteTimers();
+    }
+
+    private void Signaled()
+    {
+        try
+        {
+            ExecuteJobsCore();
+        }
+        finally
+        {
+            lock (InstanceLock)
+                _signaled = false;
+        }
+    }
+
+    void ExecuteJobsCore()
+    {
+        int? backgroundJobExecutionStartedAt = null;
+        while (true)
+        {
+            DispatcherOperation? job;
+
+            lock (InstanceLock)
+                job = _queue.Peek();
+            
+            if (job == null || job.Priority < DispatcherPriority.MinimumActiveValue)
+                return;
+            
+            
+            // We don't stop for executing jobs queued with >Input priority
+            if (job.Priority > DispatcherPriority.Input)
+            {
+                ExecuteJob(job);
+                backgroundJobExecutionStartedAt = null;
+            }
+            // If platform supports pending input query, ask the platform if we can continue running low priority jobs
+            else if (_pendingInputImpl?.CanQueryPendingInput == true)
+            {
+                if (!_pendingInputImpl.HasPendingInput)
+                    ExecuteJob(job);
+                else
+                {
+                    RequestBackgroundProcessing();
+                    return;
+                }
+            }
+            // We can't check if there is pending input, but still need to enforce interactivity
+            // so we stop processing background jobs after some timeout and start a timer to continue later
+            else
+            {
+                if (backgroundJobExecutionStartedAt == null)
+                    backgroundJobExecutionStartedAt = Clock.TickCount;
+                
+                if (Clock.TickCount - backgroundJobExecutionStartedAt.Value > MaximumTimeProcessingBackgroundJobs)
+                {
+                    _signaled = true;
+                    RequestBackgroundProcessing();
+                    return;
+                }
+                else
+                    ExecuteJob(job);
+            }
+        }
+    }
+
+    private bool RequestProcessing()
+    {
+        lock (InstanceLock)
+        {
+            if (_queue.MaxPriority <= DispatcherPriority.Input)
+                RequestBackgroundProcessing();
+            else
+                RequestForegroundProcessing();
+        }
+        return true;
+    }
+
+    private void RequestForegroundProcessing()
+    {
+        if (!_signaled)
+        {
+            _signaled = true;
+            _impl.Signal();
+        }
+    }
+
+    internal void Abort(DispatcherOperation operation)
+    {
+        lock (InstanceLock)
+            _queue.RemoveItem(operation);
+        operation.DoAbort();
+    }
+    
+    // Returns whether or not the priority was set.
+    internal bool SetPriority(DispatcherOperation operation, DispatcherPriority priority) // NOTE: should be Priority
+    {
+        bool notify = false;
+
+        lock(InstanceLock)
+        {
+            if(operation.IsQueued)
+            {
+                _queue.ChangeItemPriority(operation, priority);
+                notify = true;
+
+                if(notify)
+                {
+                    // Make sure we will wake up to process this operation.
+                    RequestProcessing();
+
+                }
+            }
+        }
+        return notify;
+    }
+
+    public bool HasJobsWithPriority(DispatcherPriority priority)
+    {
+        lock (InstanceLock)
+            return _queue.MaxPriority >= priority;
+    }
+}

src/Avalonia.Base/Threading/Dispatcher.Timers.cs

@@ -0,0 +1,171 @@
+using System;
+using System.Collections.Generic;
+
+namespace Avalonia.Threading;
+
+public partial class Dispatcher
+{
+    private List<DispatcherTimer> _timers = new();
+    private long _timersVersion;
+    private bool _dueTimeFound;
+    private int _dueTimeInTicks;
+    private bool _isOsTimerSet;
+
+    internal void UpdateOSTimer()
+    {
+        if (!CheckAccess())
+        {
+            Post(UpdateOSTimer, DispatcherPriority.Send);
+            return;
+        }
+
+        lock (InstanceLock)
+        {
+            if (!_hasShutdownFinished) // Dispatcher thread, does not technically need the lock to read
+            {
+                bool oldDueTimeFound = _dueTimeFound;
+                int oldDueTimeInTicks = _dueTimeInTicks;
+                _dueTimeFound = false;
+                _dueTimeInTicks = 0;
+
+                if (_timers.Count > 0)
+                {
+                    // We could do better if we sorted the list of timers.
+                    for (int i = 0; i < _timers.Count; i++)
+                    {
+                        var timer = _timers[i];
+
+                        if (!_dueTimeFound || timer.DueTimeInMs - _dueTimeInTicks < 0)
+                        {
+                            _dueTimeFound = true;
+                            _dueTimeInTicks = timer.DueTimeInMs;
+                        }
+                    }
+                }
+
+                if (_dueTimeFound)
+                {
+                    if (!_isOsTimerSet || !oldDueTimeFound || (oldDueTimeInTicks != _dueTimeInTicks))
+                    {
+                        _impl.UpdateTimer(Math.Max(1, _dueTimeInTicks));
+                        _isOsTimerSet = true;
+                    }
+                }
+                else if (oldDueTimeFound)
+                {
+                    _impl.UpdateTimer(null);
+                    _isOsTimerSet = false;
+                }
+            }
+        }
+    }
+
+    internal void AddTimer(DispatcherTimer timer)
+    {
+        lock (InstanceLock)
+        {
+            if (!_hasShutdownFinished) // Could be a non-dispatcher thread, lock to read
+            {
+                _timers.Add(timer);
+                _timersVersion++;
+            }
+        }
+
+        UpdateOSTimer();
+    }
+
+    internal void RemoveTimer(DispatcherTimer timer)
+    {
+        lock (InstanceLock)
+        {
+            if (!_hasShutdownFinished) // Could be a non-dispatcher thread, lock to read
+            {
+                _timers.Remove(timer);
+                _timersVersion++;
+            }
+        }
+
+        UpdateOSTimer();
+    }
+
+    private void OnOSTimer()
+    {
+        lock (InstanceLock)
+        {
+            _impl.UpdateTimer(null);
+            _isOsTimerSet = false;
+        }
+        PromoteTimers();
+    }
+    
+    internal void PromoteTimers()
+    {
+        int currentTimeInTicks = Clock.TickCount;
+        try
+        {
+            List<DispatcherTimer>? timers = null;
+            long timersVersion = 0;
+
+            lock (InstanceLock)
+            {
+                if (!_hasShutdownFinished) // Could be a non-dispatcher thread, lock to read
+                {
+                    if (_dueTimeFound && _dueTimeInTicks - currentTimeInTicks <= 0)
+                    {
+                        timers = _timers;
+                        timersVersion = _timersVersion;
+                    }
+                }
+            }
+
+            if (timers != null)
+            {
+                DispatcherTimer? timer = null;
+                int iTimer = 0;
+
+                do
+                {
+                    lock (InstanceLock)
+                    {
+                        timer = null;
+
+                        // If the timers collection changed while we are in the middle of
+                        // looking for timers, start over.
+                        if (timersVersion != _timersVersion)
+                        {
+                            timersVersion = _timersVersion;
+                            iTimer = 0;
+                        }
+
+                        while (iTimer < _timers.Count)
+                        {
+                            // WARNING: this is vulnerable to wrapping
+                            if (timers[iTimer].DueTimeInMs - currentTimeInTicks <= 0)
+                            {
+                                // Remove this timer from our list.
+                                // Do not increment the index.
+                                timer = timers[iTimer];
+                                timers.RemoveAt(iTimer);
+                                break;
+                            }
+                            else
+                            {
+                                iTimer++;
+                            }
+                        }
+                    }
+
+                    // Now that we are outside of the lock, promote the timer.
+                    if (timer != null)
+                    {
+                        timer.Promote();
+                    }
+                } while (timer != null);
+            }
+        }
+        finally
+        {
+            UpdateOSTimer();
+        }
+    }
+}

src/Avalonia.Base/Threading/Dispatcher.cs

@@ -1,159 +1,119 @@
 using System;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using System.Threading;
-using System.Threading.Tasks;
 using Avalonia.Platform;
 
-namespace Avalonia.Threading
+namespace Avalonia.Threading;
+
+/// <summary>
+/// Provides services for managing work items on a thread.
+/// </summary>
+/// <remarks>
+/// In Avalonia, there is usually only a single <see cref="Dispatcher"/> in the application -
+/// the one for the UI thread, retrieved via the <see cref="UIThread"/> property.
+/// </remarks>
+public partial class Dispatcher : IDispatcher
 {
-    /// <summary>
-    /// Provides services for managing work items on a thread.
-    /// </summary>
-    /// <remarks>
-    /// In Avalonia, there is usually only a single <see cref="Dispatcher"/> in the application -
-    /// the one for the UI thread, retrieved via the <see cref="UIThread"/> property.
-    /// </remarks>
-    public class Dispatcher : IDispatcher
+    private readonly IDispatcherImpl _impl;
+    internal IDispatcherClock Clock { get; }
+    internal object InstanceLock { get; } = new();
+    private bool _hasShutdownFinished;
+    private readonly IControlledDispatcherImpl? _controlledImpl;
+    private static Dispatcher? s_uiThread;
+    private readonly IDispatcherImplWithPendingInput? _pendingInputImpl;
+
+    internal Dispatcher(IDispatcherImpl impl, IDispatcherClock clock)
     {
-        private readonly JobRunner _jobRunner;
-        private IPlatformThreadingInterface? _platform;
-
-        public static Dispatcher UIThread { get; } =
-            new Dispatcher(AvaloniaLocator.Current.GetService<IPlatformThreadingInterface>());
-
-        public Dispatcher(IPlatformThreadingInterface? platform)
-        {
-            _platform = platform;
-            _jobRunner = new JobRunner(platform);
-
-            if (_platform != null)
-            {
-                _platform.Signaled += _jobRunner.RunJobs;
-            }
-        }
-
-        /// <summary>
-        /// Checks that the current thread is the UI thread.
-        /// </summary>
-        public bool CheckAccess() => _platform?.CurrentThreadIsLoopThread ?? true;
-
-        /// <summary>
-        /// Checks that the current thread is the UI thread and throws if not.
-        /// </summary>
-        /// <exception cref="InvalidOperationException">
-        /// The current thread is not the UI thread.
-        /// </exception>
-        public void VerifyAccess()
-        {
-            if (!CheckAccess())
-                throw new InvalidOperationException("Call from invalid thread");
-        }
-
-        /// <summary>
-        /// Runs the dispatcher's main loop.
-        /// </summary>
-        /// <param name="cancellationToken">
-        /// A cancellation token used to exit the main loop.
-        /// </param>
-        public void MainLoop(CancellationToken cancellationToken)
-        {
-            var platform = AvaloniaLocator.Current.GetRequiredService<IPlatformThreadingInterface>();
-            cancellationToken.Register(() => platform.Signal(DispatcherPriority.Send));
-            platform.RunLoop(cancellationToken);
-        }
-
-        /// <summary>
-        /// Runs continuations pushed on the loop.
-        /// </summary>
-        public void RunJobs()
-        {
-            _jobRunner.RunJobs(null);
-        }
-
-        /// <summary>
-        /// Use this method to ensure that more prioritized tasks are executed
-        /// </summary>
-        /// <param name="minimumPriority"></param>
-        public void RunJobs(DispatcherPriority minimumPriority) => _jobRunner.RunJobs(minimumPriority);
-        
-        /// <summary>
-        /// Use this method to check if there are more prioritized tasks
-        /// </summary>
-        /// <param name="minimumPriority"></param>
-        public bool HasJobsWithPriority(DispatcherPriority minimumPriority) =>
-            _jobRunner.HasJobsWithPriority(minimumPriority);
-
-        /// <inheritdoc/>
-        public Task InvokeAsync(Action action, DispatcherPriority priority = default)
-        {
-            _ = action ?? throw new ArgumentNullException(nameof(action));
-            return _jobRunner.InvokeAsync(action, priority);
-        }
-
-        /// <inheritdoc/>
-        public Task<TResult> InvokeAsync<TResult>(Func<TResult> function, DispatcherPriority priority = default)
-        {
-            _ = function ?? throw new ArgumentNullException(nameof(function));
-            return _jobRunner.InvokeAsync(function, priority);
-        }
-
-        /// <inheritdoc/>
-        public Task InvokeAsync(Func<Task> function, DispatcherPriority priority = default)
-        {
-            _ = function ?? throw new ArgumentNullException(nameof(function));
-            return _jobRunner.InvokeAsync(function, priority).Unwrap();
-        }
+        _impl = impl;
+        Clock = clock;
+        impl.Timer += OnOSTimer;
+        impl.Signaled += Signaled;
+        _controlledImpl = _impl as IControlledDispatcherImpl;
+        _pendingInputImpl = _impl as IDispatcherImplWithPendingInput;
+    }
+    
+    public static Dispatcher UIThread => s_uiThread ??= CreateUIThreadDispatcher();
 
-        /// <inheritdoc/>
-        public Task<TResult> InvokeAsync<TResult>(Func<Task<TResult>> function, DispatcherPriority priority = default)
+    private static Dispatcher CreateUIThreadDispatcher()
+    {
+        var impl = AvaloniaLocator.Current.GetService<IDispatcherImpl>();
+        if (impl == null)
         {
-            _ = function ?? throw new ArgumentNullException(nameof(function));
-            return _jobRunner.InvokeAsync(function, priority).Unwrap();
+            var platformThreading = AvaloniaLocator.Current.GetService<IPlatformThreadingInterface>();
+            if (platformThreading != null)
+                impl = new LegacyDispatcherImpl(platformThreading);
+            else
+                impl = new NullDispatcherImpl();
         }
+        return new Dispatcher(impl, impl as IDispatcherClock ?? new DefaultDispatcherClock());
+    }
 
-        /// <inheritdoc/>
-        public void Post(Action action, DispatcherPriority priority = default)
-        {
-            _ = action ?? throw new ArgumentNullException(nameof(action));
-            _jobRunner.Post(action, priority);
-        }
+    /// <summary>
+    /// Checks that the current thread is the UI thread.
+    /// </summary>
+    public bool CheckAccess() => _impl?.CurrentThreadIsLoopThread ?? true;
 
-        /// <inheritdoc/>
-        public void Post(SendOrPostCallback action, object? arg, DispatcherPriority priority = default)
+    /// <summary>
+    /// Checks that the current thread is the UI thread and throws if not.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// The current thread is not the UI thread.
+    /// </exception>
+    public void VerifyAccess()
+    {
+        if (!CheckAccess())
         {
-            _ = action ?? throw new ArgumentNullException(nameof(action));
-            _jobRunner.Post(action, arg, priority);
-        }
+            // Used to inline VerifyAccess.
+            [DoesNotReturn]
+            [MethodImpl(MethodImplOptions.NoInlining)]
+            static void ThrowVerifyAccess()
+                => throw new InvalidOperationException("Call from invalid thread");
 
-        /// <summary>
-        /// This is needed for platform backends that don't have internal priority system (e. g. win32)
-        /// To ensure that there are no jobs with higher priority
-        /// </summary>
-        /// <param name="currentPriority"></param>
-        internal void EnsurePriority(DispatcherPriority currentPriority)
-        {
-            if (currentPriority == DispatcherPriority.MaxValue)
-                return;
-            currentPriority += 1;
-            _jobRunner.RunJobs(currentPriority);
+            ThrowVerifyAccess();
         }
+    }
 
-        /// <summary>
-        /// Allows unit tests to change the platform threading interface.
-        /// </summary>
-        internal void UpdateServices()
+    internal void Shutdown()
+    {
+        DispatcherOperation? operation = null;
+        _impl.Timer -= PromoteTimers;
+        _impl.Signaled -= Signaled;
+        do
         {
-            if (_platform != null)
+            lock(InstanceLock)
             {
-                _platform.Signaled -= _jobRunner.RunJobs;
+                if(_queue.MaxPriority != DispatcherPriority.Invalid)
+                {
+                    operation = _queue.Peek();
+                }
+                else
+                {
+                    operation = null;
+                }
             }
 
-            _platform = AvaloniaLocator.Current.GetService<IPlatformThreadingInterface>();
-            _jobRunner.UpdateServices();
-
-            if (_platform != null)
+            if(operation != null)
             {
-                _platform.Signaled += _jobRunner.RunJobs;
+                operation.Abort();
             }
-        }
+        } while(operation != null);
+        _impl.UpdateTimer(null);
+        _hasShutdownFinished = true;
+    }
+
+    /// <summary>
+    /// Runs the dispatcher's main loop.
+    /// </summary>
+    /// <param name="cancellationToken">
+    /// A cancellation token used to exit the main loop.
+    /// </param>
+    public void MainLoop(CancellationToken cancellationToken)
+    {
+        if (_controlledImpl == null)
+            throw new PlatformNotSupportedException();
+        cancellationToken.Register(() => RequestProcessing());
+        _controlledImpl.RunLoop(cancellationToken);
     }
 }

src/Avalonia.Base/Threading/DispatcherOperation.cs

@@ -0,0 +1,270 @@
+using System;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Avalonia.Threading;
+
+public class DispatcherOperation
+{
+    protected readonly bool ThrowOnUiThread;
+    public DispatcherOperationStatus Status { get; protected set; }
+    public Dispatcher Dispatcher { get; }
+
+    public DispatcherPriority Priority
+    {
+        get => _priority;
+        set
+        {
+            _priority = value;
+            // Dispatcher is null in ctor
+            // ReSharper disable once ConditionalAccessQualifierIsNonNullableAccordingToAPIContract
+            Dispatcher?.SetPriority(this, value);
+        }
+    }
+
+    protected object? Callback;
+    protected object? TaskSource;
+    
+    internal DispatcherOperation? SequentialPrev { get; set; }
+    internal DispatcherOperation? SequentialNext { get; set; }
+    internal DispatcherOperation? PriorityPrev { get; set; }
+    internal DispatcherOperation? PriorityNext { get; set; }
+    internal PriorityChain? Chain { get; set; }
+    
+    internal bool IsQueued => Chain != null;
+
+    private EventHandler? _aborted;
+    private EventHandler? _completed;
+    private DispatcherPriority _priority;
+
+    internal DispatcherOperation(Dispatcher dispatcher, DispatcherPriority priority, Action callback, bool throwOnUiThread) :
+        this(dispatcher, priority, throwOnUiThread)
+    {
+        Callback = callback;
+    }
+
+    private protected DispatcherOperation(Dispatcher dispatcher, DispatcherPriority priority, bool throwOnUiThread)
+    {
+        ThrowOnUiThread = throwOnUiThread;
+        Priority = priority;
+        Dispatcher = dispatcher;
+    }
+
+    /// <summary>
+    ///     An event that is raised when the operation is aborted or canceled.
+    /// </summary>
+    public event EventHandler Aborted
+    {
+        add
+        {
+            lock (Dispatcher.InstanceLock)
+            {
+                _aborted += value;
+            }
+        }
+
+        remove
+        {
+            lock(Dispatcher.InstanceLock)
+            {
+                _aborted -= value;
+            }
+        }
+    }
+
+    /// <summary>
+    ///     An event that is raised when the operation completes.
+    /// </summary>
+    /// <remarks>
+    ///     Completed indicates that the operation was invoked and has
+    ///     either completed successfully or faulted. Note that a canceled
+    ///     or aborted operation is never is never considered completed.
+    /// </remarks>
+    public event EventHandler Completed
+    {
+        add
+        {
+            lock (Dispatcher.InstanceLock)
+            {
+                _completed += value;
+            }
+        }
+        
+        remove
+        {
+            lock(Dispatcher.InstanceLock)
+            {
+                _completed -= value;
+            }
+        }
+    }
+    
+    public void Abort()
+    {
+        lock (Dispatcher.InstanceLock)
+        {
+            if (Status == DispatcherOperationStatus.Pending)
+                return;
+            Dispatcher.Abort(this);
+        }
+    }
+
+    public void Wait()
+    {
+        if (Dispatcher.CheckAccess())
+            throw new InvalidOperationException("Wait is only supported on background thread");
+        GetTask().Wait();
+    }
+
+    public Task GetTask() => GetTaskCore();
+    
+    /// <summary>
+    ///     Returns an awaiter for awaiting the completion of the operation.
+    /// </summary>
+    /// <remarks>
+    ///     This method is intended to be used by compilers.
+    /// </remarks>
+    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+    public TaskAwaiter GetAwaiter()
+    {
+        return GetTask().GetAwaiter();
+    }
+
+    internal void DoAbort()
+    {
+        Status = DispatcherOperationStatus.Aborted;
+        AbortTask();
+        _aborted?.Invoke(this, EventArgs.Empty);
+    }
+    
+    internal void Execute()
+    {
+        lock (Dispatcher.InstanceLock)
+        {
+            Status = DispatcherOperationStatus.Executing;
+        }
+
+        try
+        {
+            InvokeCore();
+        }
+        finally
+        {
+            _completed?.Invoke(this, EventArgs.Empty);
+        }
+    }
+    
+    protected virtual void InvokeCore()
+    {
+        try
+        {
+            ((Action)Callback!)();
+            lock (Dispatcher.InstanceLock)
+            {
+                Status = DispatcherOperationStatus.Completed;
+                if (TaskSource is TaskCompletionSource<object?> tcs)
+                    tcs.SetResult(null);
+            }
+        }
+        catch (Exception e)
+        {
+            lock (Dispatcher.InstanceLock)
+            {
+                Status = DispatcherOperationStatus.Completed;
+                if (TaskSource is TaskCompletionSource<object?> tcs)
+                    tcs.SetException(e);
+            }
+
+            if (ThrowOnUiThread)
+                throw;
+        }
+    }
+
+    internal virtual object? GetResult() => null;
+    
+    protected virtual void AbortTask() => (TaskSource as TaskCompletionSource<object?>)?.SetCanceled();
+
+    private static CancellationToken CreateCancelledToken()
+    {
+        var cts = new CancellationTokenSource();
+        cts.Cancel();
+        return cts.Token;
+    }
+
+    private static readonly Task s_abortedTask = Task.FromCanceled(CreateCancelledToken());
+
+    protected virtual Task GetTaskCore()
+    {
+        lock (Dispatcher.InstanceLock)
+        {
+            if (Status == DispatcherOperationStatus.Aborted)
+                return s_abortedTask;
+            if (Status == DispatcherOperationStatus.Completed)
+                return Task.CompletedTask;
+            if (TaskSource is not TaskCompletionSource<object?> tcs)
+                TaskSource = tcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+            return tcs.Task;
+        }
+    }
+}
+
+public class DispatcherOperation<T> : DispatcherOperation
+{
+    public DispatcherOperation(Dispatcher dispatcher, DispatcherPriority priority, Func<T> callback) : base(dispatcher, priority, false)
+    {
+        TaskSource = new TaskCompletionSource<T>();
+        Callback = callback;
+    }
+
+    private TaskCompletionSource<T> TaskCompletionSource => (TaskCompletionSource<T>)TaskSource!;
+
+    public new Task<T> GetTask() => TaskCompletionSource!.Task;
+
+    protected override Task GetTaskCore() => GetTask();
+
+    protected override void AbortTask() => TaskCompletionSource.SetCanceled();
+
+    internal override object? GetResult() => GetTask().Result;
+
+    protected override void InvokeCore()
+    {
+        try
+        {
+            var result = ((Func<T>)Callback!)();
+            lock (Dispatcher.InstanceLock)
+            {
+                Status = DispatcherOperationStatus.Completed;
+                TaskCompletionSource.SetResult(result);
+            }
+        }
+        catch (Exception e)
+        {
+            lock (Dispatcher.InstanceLock)
+            {
+                Status = DispatcherOperationStatus.Completed;
+                TaskCompletionSource.SetException(e);
+            }
+        }
+    }
+
+    public T Result
+    {
+        get
+        {
+            if (TaskCompletionSource.Task.IsCompleted)
+                return TaskCompletionSource.Task.GetAwaiter().GetResult();
+            throw new InvalidOperationException("Synchronous wait is only supported on non-UI threads");
+
+        }
+    }
+}
+
+public enum DispatcherOperationStatus
+{
+    Pending = 0,
+    Aborted = 1,
+    Completed = 2,
+    Executing = 3,
+}

src/Avalonia.Base/Threading/DispatcherPriority.cs

@@ -16,31 +16,49 @@ namespace Avalonia.Threading
         {
             Value = value;
         }
-
+        
         /// <summary>
-        /// Minimum possible priority
+        /// Minimum possible priority that's actually dispatched, default value
         /// </summary>
-        public static readonly DispatcherPriority MinValue = new(0);
+        internal static readonly DispatcherPriority MinimumActiveValue = new(0);
 
+        /// <summary>
+        /// A dispatcher priority for jobs that shouldn't be executed yet
+        /// </summary>
+        public static DispatcherPriority Inactive => new(MinimumActiveValue - 1);
+        /// <summary>
+        /// Minimum valid priority
+        /// </summary>
+        internal static readonly DispatcherPriority MinValue = new(Inactive);
+        
+        /// <summary>
+        /// Used internally in dispatcher code
+        /// </summary>
+        public static DispatcherPriority Invalid => new(MinimumActiveValue - 2);
+        
+        
+        
         /// <summary>
         /// The job will be processed when the system is idle.
         /// </summary>
-        [Obsolete("WPF compatibility")] public static readonly DispatcherPriority SystemIdle = MinValue;
+        [Obsolete("WPF compatibility")] public static readonly DispatcherPriority SystemIdle = MinimumActiveValue;
 
         /// <summary>
         /// The job will be processed when the application is idle.
         /// </summary>
-        [Obsolete("WPF compatibility")] public static readonly DispatcherPriority ApplicationIdle = MinValue;
+        [Obsolete("WPF compatibility")] public static readonly DispatcherPriority ApplicationIdle = new (SystemIdle + 1);
 
         /// <summary>
         /// The job will be processed after background operations have completed.
         /// </summary>
-        [Obsolete("WPF compatibility")] public static readonly DispatcherPriority ContextIdle = MinValue;
+        [Obsolete("WPF compatibility")] public static readonly DispatcherPriority ContextIdle = new(ApplicationIdle + 1);
 
         /// <summary>
         /// The job will be processed with normal priority.
         /// </summary>
-        public static readonly DispatcherPriority Normal = MinValue;
+#pragma warning disable CS0618
+        public static readonly DispatcherPriority Normal = new(ContextIdle + 1);
+#pragma warning restore CS0618
 
         /// <summary>
         /// The job will be processed after other non-idle operations have completed.
@@ -127,5 +145,11 @@ namespace Avalonia.Threading
 
         /// <inheritdoc />
         public int CompareTo(DispatcherPriority other) => Value.CompareTo(other.Value);
+
+        public static void Validate(DispatcherPriority priority, string parameterName)
+        {
+            if (priority < Inactive || priority > MaxValue)
+                throw new ArgumentException("Invalid DispatcherPriority value", parameterName);
+        }
     }
 }

src/Avalonia.Base/Threading/DispatcherPriorityQueue.cs

@@ -0,0 +1,418 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using Avalonia.Threading;
+
+namespace Avalonia.Threading;
+
+
+internal class DispatcherPriorityQueue
+{
+    // Priority chains...
+    private readonly SortedList<int, PriorityChain> _priorityChains; // NOTE: should be Priority
+    private readonly Stack<PriorityChain> _cacheReusableChains;
+
+    // Sequential chain...
+    private DispatcherOperation? _head;
+    private DispatcherOperation? _tail;
+    
+    public DispatcherPriorityQueue()
+    {
+        // Build the collection of priority chains.
+        _priorityChains = new SortedList<int, PriorityChain>(); // NOTE: should be Priority
+        _cacheReusableChains = new Stack<PriorityChain>(10);
+
+        _head = _tail = null;
+    }
+
+    // NOTE: not used
+    // public int Count {get{return _count;}}
+
+    public DispatcherPriority MaxPriority // NOTE: should be Priority
+    {
+        get
+        {
+            int count = _priorityChains.Count;
+
+            if (count > 0)
+            {
+                return _priorityChains.Keys[count - 1];
+            }
+            else
+            {
+                return DispatcherPriority.Invalid; // NOTE: should be Priority.Invalid;
+            }
+        }
+    }
+
+    public DispatcherOperation Enqueue(DispatcherPriority priority, DispatcherOperation item) // NOTE: should be Priority
+    {
+        // Find the existing chain for this priority, or create a new one
+        // if one does not exist.
+        PriorityChain chain = GetChain(priority);
+
+        // Step 1: Append this to the end of the "sequential" linked list.
+        InsertItemInSequentialChain(item, _tail);
+
+        // Step 2: Append the item into the priority chain.
+        InsertItemInPriorityChain(item, chain, chain.Tail);
+
+        return item;
+    }
+
+    public DispatcherOperation Dequeue()
+    {
+        // Get the max-priority chain.
+        int count = _priorityChains.Count;
+        if (count > 0)
+        {
+            PriorityChain chain = _priorityChains.Values[count - 1];
+            Debug.Assert(chain != null, "PriorityQueue.Dequeue: a chain should exist.");
+
+            DispatcherOperation? item = chain.Head;
+            Debug.Assert(item != null, "PriorityQueue.Dequeue: a priority item should exist.");
+
+            RemoveItem(item);
+
+            return item;
+        }
+        else
+        {
+            throw new InvalidOperationException();
+        }
+    }
+
+    public DispatcherOperation? Peek()
+    {
+        // Get the max-priority chain.
+        int count = _priorityChains.Count;
+        if (count > 0)
+        {
+            PriorityChain chain = _priorityChains.Values[count - 1];
+            Debug.Assert(chain != null, "PriorityQueue.Peek: a chain should exist.");
+
+            DispatcherOperation? item = chain.Head;
+            Debug.Assert(item != null, "PriorityQueue.Peek: a priority item should exist.");
+
+            return item;
+        }
+
+        return null;
+    }
+    
+    public void RemoveItem(DispatcherOperation item)
+    {
+        Debug.Assert(item != null, "PriorityQueue.RemoveItem: invalid item.");
+        Debug.Assert(item.Chain != null, "PriorityQueue.RemoveItem: a chain should exist.");
+        
+        // Step 1: Remove the item from its priority chain.
+        RemoveItemFromPriorityChain(item);
+
+        // Step 2: Remove the item from the sequential chain.
+        RemoveItemFromSequentialChain(item);
+    }
+
+    public void ChangeItemPriority(DispatcherOperation item, DispatcherPriority priority) // NOTE: should be Priority
+    {
+        // Remove the item from its current priority and insert it into
+        // the new priority chain.  Note that this does not change the
+        // sequential ordering.
+
+        // Step 1: Remove the item from the priority chain.
+        RemoveItemFromPriorityChain(item);
+
+        // Step 2: Insert the item into the new priority chain.
+        // Find the existing chain for this priority, or create a new one
+        // if one does not exist.
+        PriorityChain chain = GetChain(priority);
+        InsertItemInPriorityChain(item, chain);
+    }
+
+    private PriorityChain GetChain(DispatcherPriority priority) // NOTE: should be Priority
+    {
+        PriorityChain? chain = null;
+
+        int count = _priorityChains.Count;
+        if (count > 0)
+        {
+            if (priority == _priorityChains.Keys[0])
+            {
+                chain = _priorityChains.Values[0];
+            }
+            else if (priority == _priorityChains.Keys[count - 1])
+            {
+                chain = _priorityChains.Values[count - 1];
+            }
+            else if ((priority > _priorityChains.Keys[0]) &&
+                     (priority < _priorityChains.Keys[count - 1]))
+            {
+                _priorityChains.TryGetValue(priority, out chain);
+            }
+        }
+
+        if (chain == null)
+        {
+            if (_cacheReusableChains.Count > 0)
+            {
+                chain = _cacheReusableChains.Pop();
+                chain.Priority = priority;
+            }
+            else
+            {
+                chain = new PriorityChain(priority);
+            }
+
+            _priorityChains.Add(priority, chain);
+        }
+
+        return chain;
+    }
+
+    private void InsertItemInPriorityChain(DispatcherOperation item, PriorityChain chain)
+    {
+        // Scan along the sequential chain, in the previous direction,
+        // looking for an item that is already in the new chain.  We will
+        // insert ourselves after the item we found.  We can short-circuit
+        // this search if the new chain is empty.
+        if (chain.Head == null)
+        {
+            Debug.Assert(chain.Tail == null,
+                "PriorityQueue.InsertItemInPriorityChain: both the head and the tail should be null.");
+            InsertItemInPriorityChain(item, chain, null);
+        }
+        else
+        {
+            Debug.Assert(chain.Tail != null,
+                "PriorityQueue.InsertItemInPriorityChain: both the head and the tail should not be null.");
+
+            DispatcherOperation? after;
+
+            // Search backwards along the sequential chain looking for an
+            // item already in this list.
+            for (after = item.SequentialPrev; after != null; after = after.SequentialPrev)
+            {
+                if (after.Chain == chain)
+                {
+                    break;
+                }
+            }
+
+            InsertItemInPriorityChain(item, chain, after);
+        }
+    }
+
+    internal void InsertItemInPriorityChain(DispatcherOperation item, PriorityChain chain, DispatcherOperation? after)
+    {
+        Debug.Assert(chain != null, "PriorityQueue.InsertItemInPriorityChain: a chain must be provided.");
+        Debug.Assert(item.Chain == null && item.PriorityPrev == null && item.PriorityNext == null,
+            "PriorityQueue.InsertItemInPriorityChain: item must not already be in a priority chain.");
+
+        item.Chain = chain;
+
+        if (after == null)
+        {
+            // Note: passing null for after means insert at the head.
+
+            if (chain.Head != null)
+            {
+                Debug.Assert(chain.Tail != null,
+                    "PriorityQueue.InsertItemInPriorityChain: both the head and the tail should not be null.");
+
+                chain.Head.PriorityPrev = item;
+                item.PriorityNext = chain.Head;
+                chain.Head = item;
+            }
+            else
+            {
+                Debug.Assert(chain.Tail == null,
+                    "PriorityQueue.InsertItemInPriorityChain: both the head and the tail should be null.");
+
+                chain.Head = chain.Tail = item;
+            }
+        }
+        else
+        {
+            item.PriorityPrev = after;
+
+            if (after.PriorityNext != null)
+            {
+                item.PriorityNext = after.PriorityNext;
+                after.PriorityNext.PriorityPrev = item;
+                after.PriorityNext = item;
+            }
+            else
+            {
+                Debug.Assert(item.Chain.Tail == after,
+                    "PriorityQueue.InsertItemInPriorityChain: the chain's tail should be the item we are inserting after.");
+                after.PriorityNext = item;
+                chain.Tail = item;
+            }
+        }
+
+        chain.Count++;
+    }
+
+    private void RemoveItemFromPriorityChain(DispatcherOperation item)
+    {
+        Debug.Assert(item != null, "PriorityQueue.RemoveItemFromPriorityChain: invalid item.");
+        Debug.Assert(item.Chain != null, "PriorityQueue.RemoveItemFromPriorityChain: a chain should exist.");
+
+        // Step 1: Fix up the previous link
+        if (item.PriorityPrev != null)
+        {
+            Debug.Assert(item.Chain.Head != item,
+                "PriorityQueue.RemoveItemFromPriorityChain: the head should not point to this item.");
+
+            item.PriorityPrev.PriorityNext = item.PriorityNext;
+        }
+        else
+        {
+            Debug.Assert(item.Chain.Head == item,
+                "PriorityQueue.RemoveItemFromPriorityChain: the head should point to this item.");
+
+            item.Chain.Head = item.PriorityNext;
+        }
+
+        // Step 2: Fix up the next link
+        if (item.PriorityNext != null)
+        {
+            Debug.Assert(item.Chain.Tail != item,
+                "PriorityQueue.RemoveItemFromPriorityChain: the tail should not point to this item.");
+
+            item.PriorityNext.PriorityPrev = item.PriorityPrev;
+        }
+        else
+        {
+            Debug.Assert(item.Chain.Tail == item,
+                "PriorityQueue.RemoveItemFromPriorityChain: the tail should point to this item.");
+
+            item.Chain.Tail = item.PriorityPrev;
+        }
+
+        // Step 3: cleanup
+        item.PriorityPrev = item.PriorityNext = null;
+        item.Chain.Count--;
+        if (item.Chain.Count == 0)
+        {
+            if (item.Chain.Priority == _priorityChains.Keys[_priorityChains.Count - 1])
+            {
+                _priorityChains.RemoveAt(_priorityChains.Count - 1);
+            }
+            else
+            {
+                _priorityChains.Remove(item.Chain.Priority);
+            }
+
+            if (_cacheReusableChains.Count < 10)
+            {
+                item.Chain.Priority = DispatcherPriority.Invalid;
+                _cacheReusableChains.Push(item.Chain);
+            }
+        }
+
+        item.Chain = null;
+    }
+
+    internal void InsertItemInSequentialChain(DispatcherOperation item, DispatcherOperation? after)
+    {
+        Debug.Assert(item.SequentialPrev == null && item.SequentialNext == null,
+            "PriorityQueue.InsertItemInSequentialChain: item must not already be in the sequential chain.");
+
+        if (after == null)
+        {
+            // Note: passing null for after means insert at the head.
+
+            if (_head != null)
+            {
+                Debug.Assert(_tail != null,
+                    "PriorityQueue.InsertItemInSequentialChain: both the head and the tail should not be null.");
+
+                _head.SequentialPrev = item;
+                item.SequentialNext = _head;
+                _head = item;
+            }
+            else
+            {
+                Debug.Assert(_tail == null,
+                    "PriorityQueue.InsertItemInSequentialChain: both the head and the tail should be null.");
+
+                _head = _tail = item;
+            }
+        }
+        else
+        {
+            item.SequentialPrev = after;
+
+            if (after.SequentialNext != null)
+            {
+                item.SequentialNext = after.SequentialNext;
+                after.SequentialNext.SequentialPrev = item;
+                after.SequentialNext = item;
+            }
+            else
+            {
+                Debug.Assert(_tail == after,
+                    "PriorityQueue.InsertItemInSequentialChain: the tail should be the item we are inserting after.");
+                after.SequentialNext = item;
+                _tail = item;
+            }
+        }
+    }
+
+    private void RemoveItemFromSequentialChain(DispatcherOperation item)
+    {
+        Debug.Assert(item != null, "PriorityQueue.RemoveItemFromSequentialChain: invalid item.");
+
+        // Step 1: Fix up the previous link
+        if (item.SequentialPrev != null)
+        {
+            Debug.Assert(_head != item,
+                "PriorityQueue.RemoveItemFromSequentialChain: the head should not point to this item.");
+
+            item.SequentialPrev.SequentialNext = item.SequentialNext;
+        }
+        else
+        {
+            Debug.Assert(_head == item,
+                "PriorityQueue.RemoveItemFromSequentialChain: the head should point to this item.");
+
+            _head = item.SequentialNext;
+        }
+
+        // Step 2: Fix up the next link
+        if (item.SequentialNext != null)
+        {
+            Debug.Assert(_tail != item,
+                "PriorityQueue.RemoveItemFromSequentialChain: the tail should not point to this item.");
+
+            item.SequentialNext.SequentialPrev = item.SequentialPrev;
+        }
+        else
+        {
+            Debug.Assert(_tail == item,
+                "PriorityQueue.RemoveItemFromSequentialChain: the tail should point to this item.");
+
+            _tail = item.SequentialPrev;
+        }
+
+        // Step 3: cleanup
+        item.SequentialPrev = item.SequentialNext = null;
+    }
+}
+
+
+internal class PriorityChain
+{
+    public PriorityChain(DispatcherPriority priority) // NOTE: should be Priority
+    {
+        Priority = priority;
+    }
+
+    public DispatcherPriority Priority { get; set; } // NOTE: should be Priority
+
+    public int Count { get; set; }
+
+    public DispatcherOperation? Head { get; set; }
+
+    public DispatcherOperation? Tail { get; set; }
+}

src/Avalonia.Base/Threading/DispatcherTimer.cs

@@ -1,207 +1,352 @@
 using System;
 using Avalonia.Reactive;
-using Avalonia.Platform;
 
-namespace Avalonia.Threading
+namespace Avalonia.Threading;
+
+/// <summary>
+///     A timer that is integrated into the Dispatcher queues, and will
+///     be processed after a given amount of time at a specified priority.
+/// </summary>
+public partial class DispatcherTimer
 {
     /// <summary>
-    /// A timer that uses a <see cref="Dispatcher"/> to fire at a specified interval.
+    ///     Creates a timer that uses theUI thread's Dispatcher2 to
+    ///     process the timer event at background priority.
     /// </summary>
-    public class DispatcherTimer
+    public DispatcherTimer() : this(DispatcherPriority.Background)
     {
-        private IDisposable? _timer;
+    }
 
-        private readonly DispatcherPriority _priority;
+    /// <summary>
+    ///     Creates a timer that uses the UI thread's Dispatcher2 to
+    ///     process the timer event at the specified priority.
+    /// </summary>
+    /// <param name="priority">
+    ///     The priority to process the timer at.
+    /// </param>
+    public DispatcherTimer(DispatcherPriority priority) : this(Threading.Dispatcher.UIThread, priority,
+        TimeSpan.FromMilliseconds(0))
+    {
+    }
 
-        private TimeSpan _interval;
+    /// <summary>
+    ///     Creates a timer that uses the specified Dispatcher2 to
+    ///     process the timer event at the specified priority.
+    /// </summary>
+    /// <param name="priority">
+    ///     The priority to process the timer at.
+    /// </param>
+    /// <param name="dispatcher">
+    ///     The dispatcher to use to process the timer.
+    /// </param>
+    internal DispatcherTimer(DispatcherPriority priority, Dispatcher dispatcher) : this(dispatcher, priority,
+        TimeSpan.FromMilliseconds(0))
+    {
+    }
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DispatcherTimer"/> class.
-        /// </summary>
-        public DispatcherTimer() : this(DispatcherPriority.Background)
+    /// <summary>
+    ///     Creates a timer that uses the UI thread's Dispatcher2 to
+    ///     process the timer event at the specified priority after the specified timeout.
+    /// </summary>
+    /// <param name="interval">
+    ///     The interval to tick the timer after.
+    /// </param>
+    /// <param name="priority">
+    ///     The priority to process the timer at.
+    /// </param>
+    /// <param name="callback">
+    ///     The callback to call when the timer ticks.
+    /// </param>
+    public DispatcherTimer(TimeSpan interval, DispatcherPriority priority, EventHandler callback)
+        : this(Threading.Dispatcher.UIThread, priority, interval)
+    {
+        if (callback == null)
         {
+            throw new ArgumentNullException("callback");
         }
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DispatcherTimer"/> class.
-        /// </summary>
-        /// <param name="priority">The priority to use.</param>
-        public DispatcherTimer(DispatcherPriority priority)
-        {
-            _priority = priority;
-        }
+        Tick += callback;
+        Start();
+    }
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DispatcherTimer"/> class.
-        /// </summary>
-        /// <param name="interval">The interval at which to tick.</param>
-        /// <param name="priority">The priority to use.</param>
-        /// <param name="callback">The event to call when the timer ticks.</param>
-        public DispatcherTimer(TimeSpan interval, DispatcherPriority priority, EventHandler callback) : this(priority)
-        {
-            _priority = priority;
-            Interval = interval;
-            Tick += callback;
-        }
+    /// <summary>
+    ///     Gets the dispatcher this timer is associated with.
+    /// </summary>
+    public Dispatcher Dispatcher
+    {
+        get { return _dispatcher; }
+    }
 
-        /// <summary>
-        /// Finalizes an instance of the <see cref="DispatcherTimer"/> class.
-        /// </summary>
-        ~DispatcherTimer()
+    /// <summary>
+    ///     Gets or sets whether the timer is running.
+    /// </summary>
+    public bool IsEnabled
+    {
+        get { return _isEnabled; }
+
+        set
         {
-            if (_timer != null)
+            lock (_instanceLock)
             {
-                Stop();
+                if (!value && _isEnabled)
+                {
+                    Stop();
+                }
+                else if (value && !_isEnabled)
+                {
+                    Start();
+                }
             }
         }
+    }
 
-        /// <summary>
-        /// Raised when the timer ticks.
-        /// </summary>
-        public event EventHandler? Tick;
+    /// <summary>
+    ///     Gets or sets the time between timer ticks.
+    /// </summary>
+    public TimeSpan Interval
+    {
+        get { return _interval; }
 
-        /// <summary>
-        /// Gets or sets the interval at which the timer ticks.
-        /// </summary>
-        public TimeSpan Interval
+        set
         {
-            get
+            bool updateOSTimer = false;
+
+            if (value.TotalMilliseconds < 0)
+                throw new ArgumentOutOfRangeException("value",
+                    "TimeSpan period must be greater than or equal to zero.");
+
+            if (value.TotalMilliseconds > Int32.MaxValue)
+                throw new ArgumentOutOfRangeException("value",
+                    "TimeSpan period must be less than or equal to Int32.MaxValue.");
+
+            lock (_instanceLock)
             {
-                return _interval;
+                _interval = value;
+
+                if (_isEnabled)
+                {
+                    DueTimeInMs = _dispatcher.Clock.TickCount + (int)_interval.TotalMilliseconds;
+                    updateOSTimer = true;
+                }
             }
 
-            set
+            if (updateOSTimer)
             {
-                bool enabled = IsEnabled;
-                Stop();
-                _interval = value;
-                IsEnabled = enabled;
+                _dispatcher.UpdateOSTimer();
             }
         }
+    }
 
-        /// <summary>
-        /// Gets or sets a value indicating whether the timer is running.
-        /// </summary>
-        public bool IsEnabled
+    /// <summary>
+    ///     Starts the timer.
+    /// </summary>
+    public void Start()
+    {
+        lock (_instanceLock)
         {
-            get
+            if (!_isEnabled)
             {
-                return _timer != null;
+                _isEnabled = true;
+
+                Restart();
             }
+        }
+    }
 
-            set
+    /// <summary>
+    ///     Stops the timer.
+    /// </summary>
+    public void Stop()
+    {
+        bool updateOSTimer = false;
+
+        lock (_instanceLock)
+        {
+            if (_isEnabled)
             {
-                if (IsEnabled != value)
+                _isEnabled = false;
+                updateOSTimer = true;
+
+                // If the operation is in the queue, abort it.
+                if (_operation != null)
                 {
-                    if (value)
-                    {
-                        Start();
-                    }
-                    else
-                    {
-                        Stop();
-                    }
+                    _operation.Abort();
+                    _operation = null;
                 }
             }
         }
 
-        /// <summary>
-        /// Gets or sets user-defined data associated with the timer.
-        /// </summary>
-        public object? Tag
+        if (updateOSTimer)
         {
-            get;
-            set;
+            _dispatcher.RemoveTimer(this);
         }
+    }
+    
+    /// <summary>
+    /// Starts a new timer.
+    /// </summary>
+    /// <param name="action">
+    /// The method to call on timer tick. If the method returns false, the timer will stop.
+    /// </param>
+    /// <param name="interval">The interval at which to tick.</param>
+    /// <param name="priority">The priority to use.</param>
+    /// <returns>An <see cref="IDisposable"/> used to cancel the timer.</returns>
+    public static IDisposable Run(Func<bool> action, TimeSpan interval, DispatcherPriority priority = default)
+    {
+        var timer = new DispatcherTimer(priority) { Interval = interval };
 
-        /// <summary>
-        /// Starts a new timer.
-        /// </summary>
-        /// <param name="action">
-        /// The method to call on timer tick. If the method returns false, the timer will stop.
-        /// </param>
-        /// <param name="interval">The interval at which to tick.</param>
-        /// <param name="priority">The priority to use.</param>
-        /// <returns>An <see cref="IDisposable"/> used to cancel the timer.</returns>
-        public static IDisposable Run(Func<bool> action, TimeSpan interval, DispatcherPriority priority = default)
+        timer.Tick += (s, e) =>
         {
-            var timer = new DispatcherTimer(priority) { Interval = interval };
-
-            timer.Tick += (s, e) =>
+            if (!action())
             {
-                if (!action())
-                {
-                    timer.Stop();
-                }
-            };
+                timer.Stop();
+            }
+        };
 
-            timer.Start();
+        timer.Start();
 
-            return Disposable.Create(() => timer.Stop());
-        }
+        return Disposable.Create(() => timer.Stop());
+    }
+    
+    /// <summary>
+    /// Runs a method once, after the specified interval.
+    /// </summary>
+    /// <param name="action">
+    /// The method to call after the interval has elapsed.
+    /// </param>
+    /// <param name="interval">The interval after which to call the method.</param>
+    /// <param name="priority">The priority to use.</param>
+    /// <returns>An <see cref="IDisposable"/> used to cancel the timer.</returns>
+    public static IDisposable RunOnce(
+        Action action,
+        TimeSpan interval,
+        DispatcherPriority priority = default)
+    {
+        interval = (interval != TimeSpan.Zero) ? interval : TimeSpan.FromTicks(1);
+            
+        var timer = new DispatcherTimer(priority) { Interval = interval };
 
-        /// <summary>
-        /// Runs a method once, after the specified interval.
-        /// </summary>
-        /// <param name="action">
-        /// The method to call after the interval has elapsed.
-        /// </param>
-        /// <param name="interval">The interval after which to call the method.</param>
-        /// <param name="priority">The priority to use.</param>
-        /// <returns>An <see cref="IDisposable"/> used to cancel the timer.</returns>
-        public static IDisposable RunOnce(
-            Action action,
-            TimeSpan interval,
-            DispatcherPriority priority = default)
+        timer.Tick += (s, e) =>
         {
-            interval = (interval != TimeSpan.Zero) ? interval : TimeSpan.FromTicks(1);
-            
-            var timer = new DispatcherTimer(priority) { Interval = interval };
+            action();
+            timer.Stop();
+        };
+
+        timer.Start();
+
+        return Disposable.Create(() => timer.Stop());
+    }
+
+    /// <summary>
+    ///     Occurs when the specified timer interval has elapsed and the
+    ///     timer is enabled.
+    /// </summary>
+    public event EventHandler? Tick;
+
+    /// <summary>
+    ///     Any data that the caller wants to pass along with the timer.
+    /// </summary>
+    public object? Tag { get; set; }
 
-            timer.Tick += (s, e) =>
-            {
-                action();
-                timer.Stop();
-            };
 
-            timer.Start();
+    internal DispatcherTimer(Dispatcher dispatcher, DispatcherPriority priority, TimeSpan interval)
+    {
+        if (dispatcher == null)
+        {
+            throw new ArgumentNullException("dispatcher");
+        }
 
-            return Disposable.Create(() => timer.Stop());
+        DispatcherPriority.Validate(priority, "priority");
+        if (priority == DispatcherPriority.Inactive)
+        {
+            throw new ArgumentException("Specified priority is not valid.", "priority");
         }
 
-        /// <summary>
-        /// Starts the timer.
-        /// </summary>
-        public void Start()
+        if (interval.TotalMilliseconds < 0)
+            throw new ArgumentOutOfRangeException("interval", "TimeSpan period must be greater than or equal to zero.");
+
+        if (interval.TotalMilliseconds > Int32.MaxValue)
+            throw new ArgumentOutOfRangeException("interval",
+                "TimeSpan period must be less than or equal to Int32.MaxValue.");
+
+
+        _dispatcher = dispatcher;
+        _priority = priority;
+        _interval = interval;
+    }
+
+    private void Restart()
+    {
+        lock (_instanceLock)
         {
-            if (!IsEnabled)
+            if (_operation != null)
             {
-                var threading = AvaloniaLocator.Current.GetRequiredService<IPlatformThreadingInterface>();
-                _timer = threading.StartTimer(_priority, Interval, InternalTick);
+                // Timer has already been restarted, e.g. Start was called form the Tick handler.
+                return;
+            }
+
+            // BeginInvoke a new operation.
+            _operation = _dispatcher.InvokeAsync(FireTick, DispatcherPriority.Inactive);
+
+            DueTimeInMs = _dispatcher.Clock.TickCount + (int)_interval.TotalMilliseconds;
+
+            if (_interval.TotalMilliseconds == 0 && _dispatcher.CheckAccess())
+            {
+                // shortcut - just promote the item now
+                Promote();
+            }
+            else
+            {
+                _dispatcher.AddTimer(this);
             }
         }
+    }
 
-        /// <summary>
-        /// Stops the timer.
-        /// </summary>
-        public void Stop()
+    internal void Promote() // called from Dispatcher
+    {
+        lock (_instanceLock)
         {
-            if (IsEnabled)
+            // Simply promote the operation to it's desired priority.
+            if (_operation != null)
             {
-                _timer!.Dispose();
-                _timer = null;
+                _operation.Priority = _priority;
             }
         }
+    }
 
+    private void FireTick()
+    {
+        // The operation has been invoked, so forget about it.
+        _operation = null;
 
+        // The dispatcher thread is calling us because item's priority
+        // was changed from inactive to something else.
+        if (Tick != null)
+        {
+            Tick(this, EventArgs.Empty);
+        }
 
-        /// <summary>
-        /// Raises the <see cref="Tick"/> event on the dispatcher thread.
-        /// </summary>
-        private void InternalTick()
+        // If we are still enabled, start the timer again.
+        if (_isEnabled)
         {
-            Dispatcher.UIThread.EnsurePriority(_priority);
-            Tick?.Invoke(this, EventArgs.Empty);
+            Restart();
         }
     }
-}
+
+    // This is the object we use to synchronize access.
+    private object _instanceLock = new object();
+
+    // Note: We cannot BE a dispatcher-affinity object because we can be
+    // created by a worker thread.  We are still associated with a
+    // dispatcher (where we post the item) but we can be accessed
+    // by any thread.
+    private Dispatcher _dispatcher;
+
+    private DispatcherPriority _priority; // NOTE: should be Priority
+    private TimeSpan _interval;
+    private DispatcherOperation? _operation;
+    private bool _isEnabled;
+
+    // used by Dispatcher
+    internal int DueTimeInMs { get; private set; }
+}

src/Avalonia.Base/Threading/IDispatcher.cs

@@ -26,30 +26,5 @@ namespace Avalonia.Threading
         /// <param name="action">The method.</param>
         /// <param name="priority">The priority with which to invoke the method.</param>
         void Post(Action action, DispatcherPriority priority = default);
-
-        /// <summary>
-        /// Posts an action that will be invoked on the dispatcher thread.
-        /// </summary>
-        /// <param name="action">The method.</param>
-        /// <param name="arg">The argument of method to call.</param>
-        /// <param name="priority">The priority with which to invoke the method.</param>
-        void Post(SendOrPostCallback action, object? arg, DispatcherPriority priority = default);
-
-        /// <summary>
-        /// Invokes a action on the dispatcher thread.
-        /// </summary>
-        /// <param name="action">The method.</param>
-        /// <param name="priority">The priority with which to invoke the method.</param>
-        /// <returns>A task that can be used to track the method's execution.</returns>
-        Task InvokeAsync(Action action, DispatcherPriority priority = default);
-
-        /// <summary>
-        /// Queues the specified work to run on the dispatcher thread and returns a proxy for the
-        /// task returned by <paramref name="function"/>.
-        /// </summary>
-        /// <param name="function">The work to execute asynchronously.</param>
-        /// <param name="priority">The priority with which to invoke the method.</param>
-        /// <returns>A task that represents a proxy for the task returned by <paramref name="function"/>.</returns>
-        Task InvokeAsync(Func<Task> function, DispatcherPriority priority = default);
     }
 }

src/Avalonia.Base/Threading/IDispatcherClock.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Avalonia.Threading;
+
+internal interface IDispatcherClock
+{
+    int TickCount { get; }
+}
+
+internal class DefaultDispatcherClock : IDispatcherClock
+{
+    public int TickCount => Environment.TickCount;
+}

src/Avalonia.Base/Threading/IDispatcherImpl.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Threading;
+using Avalonia.Platform;
+
+namespace Avalonia.Threading;
+
+interface IDispatcherImpl
+{
+    
+    //IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick);
+  
+    bool CurrentThreadIsLoopThread { get; }
+
+    // Asynchronously triggers Signaled callback
+    void Signal();
+    event Action Signaled;
+    event Action Timer;
+    void UpdateTimer(int? dueTimeInTicks);
+}
+
+
+interface IDispatcherImplWithPendingInput : IDispatcherImpl
+{
+    // Checks if dispatcher implementation can 
+    bool CanQueryPendingInput { get; }
+    // Checks if there is pending user input
+    bool HasPendingInput { get; }
+}
+
+interface IControlledDispatcherImpl : IDispatcherImplWithPendingInput
+{
+    // Runs the event loop
+    void RunLoop(CancellationToken token);
+}
+
+internal class LegacyDispatcherImpl : IControlledDispatcherImpl
+{
+    private readonly IPlatformThreadingInterface _platformThreading;
+    private IDisposable? _timer;
+
+    public LegacyDispatcherImpl(IPlatformThreadingInterface platformThreading)
+    {
+        _platformThreading = platformThreading;
+        _platformThreading.Signaled += delegate { Signaled?.Invoke(); };
+    }
+
+    public bool CurrentThreadIsLoopThread => _platformThreading.CurrentThreadIsLoopThread;
+    public void Signal() => _platformThreading.Signal(DispatcherPriority.Send);
+
+    public event Action? Signaled;
+    public event Action? Timer;
+    public void UpdateTimer(int? dueTimeInTicks)
+    {
+        _timer?.Dispose();
+        _timer = null;
+        if (dueTimeInTicks.HasValue)
+            _timer = _platformThreading.StartTimer(DispatcherPriority.Send,
+                TimeSpan.FromMilliseconds(dueTimeInTicks.Value),
+                OnTick);
+    }
+
+    private void OnTick()
+    {
+        _timer?.Dispose();
+        _timer = null;
+        Timer?.Invoke();
+    }
+
+    public bool CanQueryPendingInput => false;
+    public bool HasPendingInput => false;
+    public void RunLoop(CancellationToken token) => _platformThreading.RunLoop(token);
+}
+
+class NullDispatcherImpl : IDispatcherImpl
+{
+    public bool CurrentThreadIsLoopThread => true;
+
+    public void Signal()
+    {
+        
+    }
+    
+    public event Action? Signaled;
+    public event Action? Timer;
+
+    public void UpdateTimer(int? dueTimeInTicks)
+    {
+        
+    }
+}

src/Avalonia.Base/Threading/JobRunner.cs

@@ -28,7 +28,7 @@ namespace Avalonia.Threading
         /// <param name="priority">Priority to execute jobs for. Pass null if platform doesn't have internal priority system</param>
         public void RunJobs(DispatcherPriority? priority)
         {
-            var minimumPriority = priority ?? DispatcherPriority.MinValue;
+            var minimumPriority = priority ?? DispatcherPriority.MinimumActiveValue;
             while (true)
             {
                 var job = GetNextJob(minimumPriority);

src/Avalonia.Native/AvaloniaNativePlatform.cs

@@ -9,6 +9,7 @@ using Avalonia.OpenGL;
 using Avalonia.Platform;
 using Avalonia.Rendering;
 using Avalonia.Rendering.Composition;
+using Avalonia.Threading;
 using MicroCom.Runtime;
 #nullable enable
 
@@ -98,8 +99,8 @@ namespace Avalonia.Native
             }
 
             AvaloniaLocator.CurrentMutable
-                .Bind<IPlatformThreadingInterface>()
-                .ToConstant(new PlatformThreadingInterface(_factory.CreatePlatformThreadingInterface()))
+                .Bind<IDispatcherImpl>()
+                .ToConstant(new DispatcherImpl(_factory.CreatePlatformThreadingInterface()))
                 .Bind<ICursorFactory>().ToConstant(new CursorFactory(_factory.CreateCursorFactory()))
                 .Bind<IPlatformIconLoader>().ToSingleton<IconLoader>()
                 .Bind<IKeyboardDevice>().ToConstant(KeyboardDevice)

src/Avalonia.Native/CallbackBase.cs

@@ -2,6 +2,7 @@
 using System.Runtime.ExceptionServices;
 using Avalonia.MicroCom;
 using Avalonia.Platform;
+using Avalonia.Threading;
 using MicroCom.Runtime;
 
 namespace Avalonia.Native
@@ -10,11 +11,9 @@ namespace Avalonia.Native
     {
         public void RaiseException(Exception e)
         {
-            if (AvaloniaLocator.Current.GetService<IPlatformThreadingInterface>() is PlatformThreadingInterface threadingInterface)
+            if (AvaloniaLocator.Current.GetService<IDispatcherImpl>() is DispatcherImpl dispatcherImpl)
             {
-                threadingInterface.TerminateNativeApp();
-
-                threadingInterface.DispatchException(ExceptionDispatchInfo.Capture(e));
+                dispatcherImpl.PropagateCallbackException(ExceptionDispatchInfo.Capture(e));
             }
         }
     }

src/Avalonia.Native/DispatcherImpl.cs

@@ -0,0 +1,127 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+using Avalonia.Native.Interop;
+using Avalonia.Threading;
+using MicroCom.Runtime;
+
+namespace Avalonia.Native;
+
+internal class DispatcherImpl : IControlledDispatcherImpl, IDispatcherClock
+{
+    private readonly IAvnPlatformThreadingInterface _native;
+    private Thread? _loopThread;
+    private Stack<RunLoopFrame> _managedFrames = new();
+
+    public DispatcherImpl(IAvnPlatformThreadingInterface native)
+    {
+        _native = native;
+        using var events = new Events(this);
+        _native.SetEvents(events);
+    }
+    
+    public event Action Signaled;
+    public event Action Timer;
+    
+    private class Events : NativeCallbackBase, IAvnPlatformThreadingInterfaceEvents
+    {
+        private readonly DispatcherImpl _parent;
+
+        public Events(DispatcherImpl parent)
+        {
+            _parent = parent;
+        }
+        public void Signaled() => _parent.Signaled?.Invoke();
+
+        public void Timer() => _parent.Timer?.Invoke();
+    }
+
+    public bool CurrentThreadIsLoopThread
+    {
+        get
+        {
+            if (_loopThread != null)
+                return Thread.CurrentThread == _loopThread;
+            if (_native.CurrentThreadIsLoopThread == 0)
+                return false;
+            _loopThread = Thread.CurrentThread;
+            return true;
+        }
+    }
+
+    public void Signal() => _native.Signal();
+
+    public void UpdateTimer(int? dueTimeInTicks)
+    {
+        var ms = dueTimeInTicks == null ? -1 : Math.Max(1, dueTimeInTicks.Value - TickCount);
+        _native.UpdateTimer(ms);
+    }
+
+    public bool CanQueryPendingInput => true;
+    public bool HasPendingInput => _native.HasPendingInput() != 0;
+
+    class RunLoopFrame : IDisposable
+    {
+        public ExceptionDispatchInfo? Exception;
+        public CancellationTokenSource CancellationTokenSource = new();
+
+        public RunLoopFrame(CancellationToken token)
+        {
+            CancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token);
+        }
+
+        public void Dispose() => CancellationTokenSource.Dispose();
+    }
+    
+    public void RunLoop(CancellationToken token)
+    {
+        if (token.IsCancellationRequested)
+            return;
+        object l = new();
+        var exited = false;
+        
+        using var frame = new RunLoopFrame(token);
+        
+        using var cancel = _native.CreateLoopCancellation();
+        frame.CancellationTokenSource.Token.Register(() =>
+        {
+            lock (l)
+                // ReSharper disable once AccessToModifiedClosure
+                // ReSharper disable once AccessToDisposedClosure
+                if (!exited)
+                    cancel.Cancel();
+        });
+        
+        try
+        {
+            _managedFrames.Push(frame);
+            _native.RunLoop(cancel);
+        }
+        finally
+        {
+            lock (l)
+                exited = true;
+            _managedFrames.Pop();
+            if (frame.Exception != null)
+                frame.Exception.Throw();
+        }
+    }
+
+    public int TickCount => Environment.TickCount;
+
+    public void PropagateCallbackException(ExceptionDispatchInfo capture)
+    {
+        if (_managedFrames.Count == 0)
+        {
+            Debug.Assert(false, "We should never get here");
+            return;
+        }
+
+        var frame = _managedFrames.Peek();
+        frame.Exception = capture;
+        frame.CancellationTokenSource.Cancel();
+    }
+}

src/Avalonia.Native/PlatformThreadingInterface.cs

@@ -1,115 +0,0 @@
-using System;
-using System.Runtime.ExceptionServices;
-using System.Threading;
-using Avalonia.Native.Interop;
-using Avalonia.Platform;
-using Avalonia.Threading;
-
-namespace Avalonia.Native
-{
-    internal class PlatformThreadingInterface : IPlatformThreadingInterface
-    {
-        class TimerCallback : NativeCallbackBase, IAvnActionCallback
-        {
-            readonly Action _tick;
-
-            public TimerCallback(Action tick)
-            {
-                _tick = tick;
-            }
-
-            public void Run()
-            {
-                _tick();
-            }
-        }
-
-        class SignaledCallback : NativeCallbackBase, IAvnSignaledCallback
-        {
-            readonly PlatformThreadingInterface _parent;
-
-            public SignaledCallback(PlatformThreadingInterface parent)
-            {
-                _parent = parent;
-            }
-
-            public void Signaled(int priority, int priorityContainsMeaningfulValue)
-            {
-                _parent.Signaled?.Invoke(priorityContainsMeaningfulValue.FromComBool() ? (DispatcherPriority?)priority : null);
-            }
-        }
-
-        readonly IAvnPlatformThreadingInterface _native;
-        private ExceptionDispatchInfo _exceptionDispatchInfo;
-        private CancellationTokenSource _exceptionCancellationSource;
-
-        public PlatformThreadingInterface(IAvnPlatformThreadingInterface native)
-        {
-            _native = native;
-            using (var cb = new SignaledCallback(this))
-                _native.SetSignaledCallback(cb);
-        }
-
-        public bool CurrentThreadIsLoopThread => _native.CurrentThreadIsLoopThread.FromComBool();
-
-        public event Action<DispatcherPriority?> Signaled;
-
-        public void RunLoop(CancellationToken cancellationToken)
-        {
-            _exceptionDispatchInfo?.Throw();
-            var l = new object();
-            _exceptionCancellationSource = new CancellationTokenSource();
-
-            var compositeCancellation = CancellationTokenSource
-                .CreateLinkedTokenSource(cancellationToken, _exceptionCancellationSource.Token).Token;
-
-            var cancellation = _native.CreateLoopCancellation();
-            compositeCancellation.Register(() =>
-            {
-                lock (l)
-                {
-                    cancellation?.Cancel();
-                }
-            });
-
-            try
-            {
-                _native.RunLoop(cancellation);
-            }
-            finally
-            {
-                lock (l)
-                {
-                    cancellation?.Dispose();
-                    cancellation = null;
-                }
-            }
-
-            if (_exceptionDispatchInfo != null)
-            {
-                _exceptionDispatchInfo.Throw();
-            }
-        }
-
-        public void DispatchException (ExceptionDispatchInfo exceptionInfo)
-        {
-            _exceptionDispatchInfo = exceptionInfo;
-        }
-
-        public void TerminateNativeApp()
-        {
-            _exceptionCancellationSource?.Cancel();
-        }
-
-        public void Signal(DispatcherPriority priority)
-        {
-            _native.Signal((int)priority);
-        }
-
-        public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick)
-        {
-            using (var cb = new TimerCallback(tick))
-                return _native.StartTimer((int)priority, (int)interval.TotalMilliseconds, cb);
-        }
-    }
-}

src/Avalonia.Native/avn.idl

@@ -645,9 +645,10 @@ interface IAvnActionCallback : IUnknown
 }
 
 [uuid(6df4d2db-0b80-4f59-ad88-0baa5e21eb14)]
-interface IAvnSignaledCallback : IUnknown
+interface IAvnPlatformThreadingInterfaceEvents : IUnknown
 {
-     void Signaled(int priority, bool priorityContainsMeaningfulValue);
+     void Signaled();
+     void Timer();
 }
 
 [uuid(97330f88-c22b-4a8e-a130-201520091b01)]
@@ -660,12 +661,12 @@ interface IAvnLoopCancellation : IUnknown
 interface IAvnPlatformThreadingInterface : IUnknown
 {
      bool GetCurrentThreadIsLoopThread();
-     void SetSignaledCallback(IAvnSignaledCallback* cb);
+     bool HasPendingInput();
+     void SetEvents(IAvnPlatformThreadingInterfaceEvents* cb);
      IAvnLoopCancellation* CreateLoopCancellation();
-     HRESULT RunLoop(IAvnLoopCancellation* cancel);
-    // Can't pass int* to sharpgentools for some reason
-     void Signal(int priority);
-     IUnknown* StartTimer(int priority, int ms, IAvnActionCallback* callback);
+     void RunLoop(IAvnLoopCancellation* cancel);
+     void Signal();
+     void UpdateTimer(int ms);
 }
 
 [uuid(6c621a6e-e4c1-4ae3-9749-83eeeffa09b6)]

src/Avalonia.X11/X11Platform.cs

@@ -14,6 +14,7 @@ using Avalonia.OpenGL.Egl;
 using Avalonia.Platform;
 using Avalonia.Rendering;
 using Avalonia.Rendering.Composition;
+using Avalonia.Threading;
 using Avalonia.X11;
 using Avalonia.X11.Glx;
 using static Avalonia.X11.XLib;
@@ -34,6 +35,7 @@ namespace Avalonia.X11
         public X11PlatformOptions Options { get; private set; }
         public IntPtr OrphanedWindow { get; private set; }
         public X11Globals Globals { get; private set; }
+        public ManualRawEventGrouperDispatchQueue EventGrouperDispatchQueue { get; } = new();
         [DllImport("libc")]
         private static extern void setlocale(int type, string s);
         public void Initialize(X11PlatformOptions options)
@@ -72,7 +74,7 @@ namespace Avalonia.X11
 
             AvaloniaLocator.CurrentMutable.BindToSelf(this)
                 .Bind<IWindowingPlatform>().ToConstant(this)
-                .Bind<IPlatformThreadingInterface>().ToConstant(new X11PlatformThreading(this))
+                .Bind<IDispatcherImpl>().ToConstant(new X11PlatformThreading(this))
                 .Bind<IRenderTimer>().ToConstant(new SleepLoopRenderTimer(60))
                 .Bind<IRenderLoop>().ToConstant(new RenderLoop())
                 .Bind<PlatformHotkeyConfiguration>().ToConstant(new PlatformHotkeyConfiguration(KeyModifiers.Control))

src/Avalonia.X11/X11PlatformThreading.cs

@@ -9,7 +9,7 @@ using static Avalonia.X11.XLib;
 
 namespace Avalonia.X11
 {
-    internal unsafe class X11PlatformThreading : IPlatformThreadingInterface
+    internal unsafe class X11PlatformThreading : IControlledDispatcherImpl, IDispatcherClock
     {
         private readonly AvaloniaX11Platform _platform;
         private readonly IntPtr _display;
@@ -68,44 +68,11 @@ namespace Avalonia.X11
         private int _sigread, _sigwrite;
         private object _lock = new object();
         private bool _signaled;
-        private DispatcherPriority _signaledPriority;
+        private bool _wakeupRequested;
+        private long? _nextTimer;
         private int _epoll;
         private Stopwatch _clock = Stopwatch.StartNew();
 
-        private class X11Timer : IDisposable
-        {
-            private readonly X11PlatformThreading _parent;
-
-            public X11Timer(X11PlatformThreading parent, DispatcherPriority prio, TimeSpan interval, Action tick)
-            {
-                _parent = parent;
-                Priority = prio;
-                Tick = tick;
-                Interval = interval;
-                Reschedule();
-            }
-            
-            public DispatcherPriority Priority { get; }
-            public TimeSpan NextTick { get; private set; }
-            public TimeSpan Interval { get; }
-            public Action Tick { get; }
-            public bool Disposed { get; private set; }
-
-            public void Reschedule()
-            {
-                NextTick = _parent._clock.Elapsed + Interval;
-            }
-
-            public void Dispose()
-            {
-                Disposed = true;
-                lock (_parent._lock)
-                    _parent._timers.Remove(this);
-            }
-        }
-
-        private List<X11Timer> _timers = new List<X11Timer>();
-        
         public X11PlatformThreading(AvaloniaX11Platform platform)
         {
             _platform = platform;
@@ -139,29 +106,16 @@ namespace Avalonia.X11
                 throw new X11Exception("Unable to attach signal pipe to epoll");
         }
 
-        private int TimerComparer(X11Timer t1, X11Timer t2)
-        {
-            return t2.Priority - t1.Priority;
-        }
-
         private void CheckSignaled()
         {
-            int buf = 0;
-            while (read(_sigread, &buf, new IntPtr(4)).ToInt64() > 0)
-            {
-            }
-
-            DispatcherPriority prio;
             lock (_lock)
             {
                 if (!_signaled)
                     return;
                 _signaled = false;
-                prio = _signaledPriority;
-                _signaledPriority = DispatcherPriority.MinValue;
             }
 
-            Signaled?.Invoke(prio);
+            Signaled?.Invoke();
         }
 
         private unsafe void HandleX11(CancellationToken cancellationToken)
@@ -170,6 +124,7 @@ namespace Avalonia.X11
             {
                 if (cancellationToken.IsCancellationRequested)
                     return;
+                
                 XNextEvent(_display, out var xev);
                 if(XFilterEvent(ref xev, IntPtr.Zero))
                     continue;
@@ -195,90 +150,94 @@ namespace Avalonia.X11
                         XFreeEventData(_display, &xev.GenericEventCookie);
                 }
             }
-
-            Dispatcher.UIThread.RunJobs();
         }
-        
+
         public void RunLoop(CancellationToken cancellationToken)
         {
-            var readyTimers = new List<X11Timer>();
             while (!cancellationToken.IsCancellationRequested)
             {
-                var now = _clock.Elapsed;
-                TimeSpan? nextTick = null;
-                readyTimers.Clear();
-                lock(_timers)
-                    foreach (var t in _timers)
-                    {
-                        if (nextTick == null || t.NextTick < nextTick.Value)
-                            nextTick = t.NextTick;
-                        if (t.NextTick < now)
-                            readyTimers.Add(t);
-                    }
-                
-                readyTimers.Sort(TimerComparer);
-                
-                foreach (var t in readyTimers)
+                var now = _clock.ElapsedMilliseconds;
+                if (_nextTimer.HasValue && now > _nextTimer.Value)
                 {
-                    if (cancellationToken.IsCancellationRequested)
-                        return;
-                    t.Tick();
-                    if(!t.Disposed)
-                    {
-                        t.Reschedule();
-                        if (nextTick == null || t.NextTick < nextTick.Value)
-                            nextTick = t.NextTick;
-                    }
+                    Timer?.Invoke();
                 }
 
                 if (cancellationToken.IsCancellationRequested)
                     return;
+                
                 //Flush whatever requests were made to XServer
                 XFlush(_display);
                 epoll_event ev;
                 if (XPending(_display) == 0)
-                    epoll_wait(_epoll, &ev, 1,
-                        nextTick == null ? -1 : Math.Max(1, (int)(nextTick.Value - _clock.Elapsed).TotalMilliseconds));
+                {
+                    now = _clock.ElapsedMilliseconds;
+                    if (_nextTimer < now)
+                        continue;
+                    
+                    var timeout = _nextTimer == null ? (int)-1 : Math.Max(1, _nextTimer.Value - now);
+                    epoll_wait(_epoll, &ev, 1, (int)Math.Min(int.MaxValue, timeout));
+                    
+                    // Drain the signaled pipe
+                    int buf = 0;
+                    while (read(_sigread, &buf, new IntPtr(4)).ToInt64() > 0)
+                    {
+                    }
+
+                    lock (_lock)
+                        _wakeupRequested = false;
+                }
+
                 if (cancellationToken.IsCancellationRequested)
                     return;
                 CheckSignaled();
                 HandleX11(cancellationToken);
+                while (_platform.EventGrouperDispatchQueue.HasJobs)
+                {
+                    CheckSignaled();
+                    _platform.EventGrouperDispatchQueue.DispatchNext();
+                }
             }
         }
 
-        
+        private void Wakeup()
+        {
+            lock (_lock)
+            {
+                if(_wakeupRequested)
+                    return;
+                _wakeupRequested = true;
+                int buf = 0;
+                write(_sigwrite, &buf, new IntPtr(1));
+            }
+        }
 
-        public void Signal(DispatcherPriority priority)
+        public void Signal()
         {
             lock (_lock)
             {
-                if (priority > _signaledPriority)
-                    _signaledPriority = priority;
-                
                 if(_signaled)
                     return;
                 _signaled = true;
-                int buf = 0;
-                write(_sigwrite, &buf, new IntPtr(1));
+                Wakeup();
             }
         }
 
         public bool CurrentThreadIsLoopThread => Thread.CurrentThread == _mainThread;
-        public event Action<DispatcherPriority?> Signaled;
         
-        public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick)
+        public event Action Signaled;
+        public event Action Timer;
+
+        public void UpdateTimer(int? dueTimeInTicks)
         {
-            if (_mainThread != Thread.CurrentThread)
-                throw new InvalidOperationException("StartTimer can be only called from UI thread");
-            if (interval <= TimeSpan.Zero)
-                throw new ArgumentException("Interval must be positive", nameof(interval));
-            
-            // We assume that we are on the main thread and outside of epoll_wait, so there is no need for wakeup signal
-            
-            var timer = new X11Timer(this, priority, interval, tick);
-            lock(_timers)
-                _timers.Add(timer);
-            return timer;
+            _nextTimer = dueTimeInTicks;
+            if (_nextTimer != null)
+                Wakeup();
         }
+
+
+        public int TickCount => (int)_clock.ElapsedMilliseconds;
+        public bool CanQueryPendingInput => true;
+
+        public bool HasPendingInput => _platform.EventGrouperDispatchQueue.HasJobs || XPending(_display) != 0;
     }
 }

src/Avalonia.X11/X11Window.cs

@@ -187,7 +187,7 @@ namespace Avalonia.X11
             UpdateMotifHints();
             UpdateSizeHints(null);
 
-            _rawEventGrouper = new RawEventGrouper(DispatchInput);
+            _rawEventGrouper = new RawEventGrouper(DispatchInput, platform.EventGrouperDispatchQueue);
             
             _transparencyHelper = new TransparencyHelper(_x11, _handle, platform.Globals);
             _transparencyHelper.SetTransparencyRequest(WindowTransparencyLevel.None);
@@ -507,7 +507,6 @@ namespace Avalonia.X11
                         if (changedSize && !updatedSizeViaScaling && !_popup)
                             Resized?.Invoke(ClientSize, PlatformResizeReason.Unspecified);
 
-                        Dispatcher.UIThread.RunJobs(DispatcherPriority.Layout);
                     }, DispatcherPriority.Layout);
                 if (_useRenderWindow)
                     XConfigureResizeWindow(_x11.Display, _renderHandle, ev.ConfigureEvent.width,

src/Shared/RawEventGrouping.cs

@@ -12,28 +12,47 @@ namespace Avalonia;
   While doing that it groups Move and TouchUpdate events so we could provide GetIntermediatePoints API
  */
 
-internal class RawEventGrouper : IDisposable
+internal interface IRawEventGrouperDispatchQueue
 {
-    private readonly Action<RawInputEventArgs> _eventCallback;
-    private readonly Queue<RawInputEventArgs> _inputQueue = new();
+    void Add(RawInputEventArgs args, Action<RawInputEventArgs> handler);
+}
+
+
+class ManualRawEventGrouperDispatchQueue : IRawEventGrouperDispatchQueue
+{
+    private readonly Queue<(RawInputEventArgs args, Action<RawInputEventArgs> handler)> _inputQueue = new();
+    public void Add(RawInputEventArgs args, Action<RawInputEventArgs> handler) => _inputQueue.Enqueue((args, handler));
+
+    public bool HasJobs => _inputQueue.Count > 0;
+    
+    public void DispatchNext()
+    {
+        if (_inputQueue.Count == 0)
+            return;
+        var ev = _inputQueue.Dequeue();
+        ev.handler(ev.args);
+    }
+}
+
+internal class AutomaticRawEventGrouperDispatchQueue : IRawEventGrouperDispatchQueue
+{
+    private readonly Queue<(RawInputEventArgs args, Action<RawInputEventArgs> handler)> _inputQueue = new();
     private readonly Action _dispatchFromQueue;
-    private readonly Dictionary<long, RawPointerEventArgs> _lastTouchPoints = new();
-    private RawInputEventArgs? _lastEvent;
 
-    public RawEventGrouper(Action<RawInputEventArgs> eventCallback)
+    public AutomaticRawEventGrouperDispatchQueue()
     {
-        _eventCallback = eventCallback;
         _dispatchFromQueue = DispatchFromQueue;
     }
     
-    private void AddToQueue(RawInputEventArgs args)
+    public void Add(RawInputEventArgs args, Action<RawInputEventArgs> handler)
     {
-        _lastEvent = args;
-        _inputQueue.Enqueue(args);
+        _inputQueue.Enqueue((args, handler));
+        
         if (_inputQueue.Count == 1)
             Dispatcher.UIThread.Post(_dispatchFromQueue, DispatcherPriority.Input);
+        
     }
-
+    
     private void DispatchFromQueue()
     {
         while (true)
@@ -43,17 +62,8 @@ internal class RawEventGrouper : IDisposable
 
             var ev = _inputQueue.Dequeue();
 
-            if (_lastEvent == ev) 
-                _lastEvent = null;
+            ev.handler(ev.args);
             
-            if (ev is RawTouchEventArgs { Type: RawPointerEventType.TouchUpdate } touchUpdate)
-                _lastTouchPoints.Remove(touchUpdate.RawPointerId);
-
-            _eventCallback?.Invoke(ev);
-
-            if (ev is RawPointerEventArgs { IntermediatePoints.Value: PooledList<RawPointerPoint> list }) 
-                list.Dispose();
-
             if (Dispatcher.UIThread.HasJobsWithPriority(DispatcherPriority.Input + 1))
             {
                 Dispatcher.UIThread.Post(_dispatchFromQueue, DispatcherPriority.Input);
@@ -61,6 +71,47 @@ internal class RawEventGrouper : IDisposable
             }
         }
     }
+}
+
+internal class RawEventGrouper : IDisposable
+{
+    private readonly Action<RawInputEventArgs> _eventCallback;
+    private readonly IRawEventGrouperDispatchQueue _queue;
+    private readonly Dictionary<long, RawPointerEventArgs> _lastTouchPoints = new();
+    private RawInputEventArgs? _lastEvent;
+    private Action<RawInputEventArgs> _dispatch;
+    private bool _disposed;
+
+    public RawEventGrouper(Action<RawInputEventArgs> eventCallback, IRawEventGrouperDispatchQueue? queue = null)
+    {
+        _eventCallback = eventCallback;
+        _queue = queue ?? new AutomaticRawEventGrouperDispatchQueue();
+        _dispatch = Dispatch;
+    }
+    
+    private void AddToQueue(RawInputEventArgs args)
+    {
+        _lastEvent = args;
+        _queue.Add(args, _dispatch);
+    }
+
+    private void Dispatch(RawInputEventArgs ev)
+    {
+        if (!_disposed)
+        {
+            if (_lastEvent == ev)
+                _lastEvent = null;
+
+            if (ev is RawTouchEventArgs { Type: RawPointerEventType.TouchUpdate } touchUpdate)
+                _lastTouchPoints.Remove(touchUpdate.RawPointerId);
+            
+            _eventCallback?.Invoke(ev);
+        }
+
+        if (ev is RawPointerEventArgs { IntermediatePoints.Value: PooledList<RawPointerPoint> list }) 
+            list.Dispose();
+    }
+
     
     public void HandleEvent(RawInputEventArgs args)
     {
@@ -123,7 +174,7 @@ internal class RawEventGrouper : IDisposable
 
     public void Dispose()
     {
-        _inputQueue.Clear();
+        _disposed = true;
         _lastEvent = null;
         _lastTouchPoints.Clear();
     }

src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs

@@ -1784,6 +1784,49 @@ namespace Avalonia.Win32.Interop
             return result;
         }
 
+        [Flags]
+        internal enum QueueStatusFlags
+        {
+            QS_KEY = 0x0001,
+            QS_MOUSEMOVE = 0x0002,
+            QS_MOUSEBUTTON = 0x0004,
+            QS_POSTMESSAGE = 0x0008,
+            QS_TIMER = 0x0010,
+            QS_PAINT = 0x0020,
+            QS_SENDMESSAGE = 0x0040,
+            QS_HOTKEY = 0x0080,
+            QS_ALLPOSTMESSAGE = 0x0100,
+            QS_EVENT = 0x0200,
+            QS_MOUSE = QS_MOUSEMOVE | QS_MOUSEBUTTON,
+            QS_INPUT = QS_MOUSE | QS_KEY,
+            QS_ALLEVENTS = QS_INPUT | QS_POSTMESSAGE | QS_TIMER | QS_PAINT | QS_HOTKEY,
+            QS_ALLINPUT = QS_INPUT | QS_POSTMESSAGE | QS_TIMER | QS_PAINT | QS_HOTKEY | QS_SENDMESSAGE
+        }
+
+        [Flags]
+        internal enum MsgWaitForMultipleObjectsFlags
+        {
+            MWMO_WAITALL = 0x0001,
+            MWMO_ALERTABLE = 0x0002,
+            MWMO_INPUTAVAILABLE = 0x0004
+        }
+
+        [DllImport("user32", EntryPoint="MsgWaitForMultipleObjectsEx", SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto)]
+        private static extern int IntMsgWaitForMultipleObjectsEx(int nCount, IntPtr[]? pHandles, int dwMilliseconds,
+            QueueStatusFlags dwWakeMask, MsgWaitForMultipleObjectsFlags dwFlags);
+
+        internal static int MsgWaitForMultipleObjectsEx(int nCount, IntPtr[]? pHandles, int dwMilliseconds, 
+            QueueStatusFlags dwWakeMask, MsgWaitForMultipleObjectsFlags dwFlags)
+        {
+            int result = IntMsgWaitForMultipleObjectsEx(nCount, pHandles, dwMilliseconds, dwWakeMask, dwFlags);
+            if(result == -1)
+            {
+                throw new Win32Exception();
+            }
+
+            return result;
+        }
+
         [DllImport("user32.dll")]
         internal static extern int SetWindowCompositionAttribute(IntPtr hwnd, ref WindowCompositionAttributeData data);
 

src/Windows/Avalonia.Win32/Win32DispatcherImpl.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+using Avalonia.Threading;
+using Avalonia.Win32.Interop;
+using static Avalonia.Win32.Interop.UnmanagedMethods;
+namespace Avalonia.Win32;
+
+internal class Win32DispatcherImpl : IControlledDispatcherImpl, IDispatcherClock
+{
+    private readonly IntPtr _messageWindow;
+    private static Thread? s_uiThread;
+    private IntPtr? _timerHandle;
+    private readonly TimerProc _timerDelegate;
+    public Win32DispatcherImpl(IntPtr messageWindow)
+    {
+        _messageWindow = messageWindow;
+        s_uiThread = Thread.CurrentThread;
+        _timerDelegate = TimerProc;
+    }
+    
+    public bool CurrentThreadIsLoopThread => s_uiThread == Thread.CurrentThread;
+    internal const int SignalW = unchecked((int)0xdeadbeaf);
+    internal const int SignalL = unchecked((int)0x12345678);
+
+    public void Signal() =>
+        // Messages from PostMessage are always processed before any user input,
+        // so Win32 should call us ASAP
+        PostMessage(
+            _messageWindow,
+            (int)WindowsMessage.WM_DISPATCH_WORK_ITEM,
+            new IntPtr(SignalW),
+            new IntPtr(SignalL));
+    
+    public void DispatchWorkItem() => Signaled?.Invoke();
+    
+    public event Action? Signaled;
+    public event Action? Timer;
+
+    void TimerProc(IntPtr hWnd, uint uMsg, IntPtr nIdEvent, uint dwTime) => Timer?.Invoke();
+
+    public void UpdateTimer(int? dueTimeInTicks)
+    {
+        if (_timerHandle.HasValue)
+            KillTimer(IntPtr.Zero, _timerHandle.Value);
+        if (dueTimeInTicks == null)
+            return;
+
+        var interval = (uint)Math.Max(1, TickCount - dueTimeInTicks.Value);
+
+        _timerHandle = SetTimer(
+            IntPtr.Zero,
+            IntPtr.Zero,
+            interval,
+            _timerDelegate);
+    }
+
+    public bool CanQueryPendingInput => true;
+
+    public bool HasPendingInput
+    {
+        get
+        {
+            // We need to know if there is any pending input in the Win32
+            // queue because we want to only process Avalon "background"
+            // items after Win32 input has been processed.
+            //
+            // Win32 provides the GetQueueStatus API -- but it has a major
+            // drawback: it only counts "new" input.  This means that
+            // sometimes it could return false, even if there really is input
+            // that needs to be processed.  This results in very hard to
+            // find bugs.
+            //
+            // Luckily, Win32 also provides the MsgWaitForMultipleObjectsEx
+            // API.  While more awkward to use, this API can return queue
+            // status information even if the input is "old".  The various
+            // flags we use are:
+            //
+            // QS_INPUT
+            // This represents any pending input - such as mouse moves, or
+            // key presses.  It also includes the new GenericInput messages.
+            //
+            // QS_EVENT
+            // This is actually a private flag that represents the various
+            // events that can be queued in Win32.  Some of these events
+            // can cause input, but Win32 doesn't include them in the
+            // QS_INPUT flag.  An example is WM_MOUSELEAVE.
+            //
+            // QS_POSTMESSAGE
+            // If there is already a message in the queue, we need to process
+            // it before we can process input.
+            //
+            // MWMO_INPUTAVAILABLE
+            // This flag indicates that any input (new or old) is to be
+            // reported.
+            //
+
+            return MsgWaitForMultipleObjectsEx(0, null, 0,
+                QueueStatusFlags.QS_INPUT | QueueStatusFlags.QS_EVENT | QueueStatusFlags.QS_POSTMESSAGE,
+                MsgWaitForMultipleObjectsFlags.MWMO_INPUTAVAILABLE) == 0;
+        }
+    }
+
+    public void RunLoop(CancellationToken cancellationToken)
+    {
+        var result = 0;
+        while (!cancellationToken.IsCancellationRequested 
+               && (result = GetMessage(out var msg, IntPtr.Zero, 0, 0)) > 0)
+        {
+            TranslateMessage(ref msg);
+            DispatchMessage(ref msg);
+        }
+        if (result < 0)
+        {
+            Logging.Logger.TryGet(Logging.LogEventLevel.Error, Logging.LogArea.Win32Platform)
+                ?.Log(this, "Unmanaged error in {0}. Error Code: {1}", nameof(RunLoop), Marshal.GetLastWin32Error());
+        }
+    }
+
+    public int TickCount => Environment.TickCount;
+}

src/Windows/Avalonia.Win32/Win32Platform.cs

@@ -107,21 +107,21 @@ namespace Avalonia
 
 namespace Avalonia.Win32
 {
-    internal class Win32Platform : IPlatformThreadingInterface, IWindowingPlatform, IPlatformIconLoader, IPlatformLifetimeEventsImpl
+    internal class Win32Platform : IWindowingPlatform, IPlatformIconLoader, IPlatformLifetimeEventsImpl
     {
         private static readonly Win32Platform s_instance = new();
-        private static Thread? s_uiThread;
         private static Win32PlatformOptions? s_options;
         private static Compositor? s_compositor;
 
         private WndProc? _wndProcDelegate;
         private IntPtr _hwnd;
-        private readonly List<Delegate> _delegates = new();
+        private Win32DispatcherImpl _dispatcher;
 
         public Win32Platform()
         {
             SetDpiAwareness();
             CreateMessageWindow();
+            _dispatcher = new Win32DispatcherImpl(_hwnd);
         }
 
         internal static Win32Platform Instance => s_instance;
@@ -157,7 +157,7 @@ namespace Avalonia.Win32
                 .Bind<ICursorFactory>().ToConstant(CursorFactory.Instance)
                 .Bind<IKeyboardDevice>().ToConstant(WindowsKeyboardDevice.Instance)
                 .Bind<IPlatformSettings>().ToSingleton<Win32PlatformSettings>()
-                .Bind<IPlatformThreadingInterface>().ToConstant(s_instance)
+                .Bind<IDispatcherImpl>().ToConstant(s_instance._dispatcher)
                 .Bind<IRenderLoop>().ToConstant(new RenderLoop())
                 .Bind<IRenderTimer>().ToConstant(renderTimer)
                 .Bind<IWindowingPlatform>().ToConstant(s_instance)
@@ -174,8 +174,6 @@ namespace Avalonia.Win32
                 .Bind<IMountedVolumeInfoProvider>().ToConstant(new WindowsMountedVolumeInfoProvider())
                 .Bind<IPlatformLifetimeEventsImpl>().ToConstant(s_instance);
             
-            s_uiThread = Thread.CurrentThread;
-
             var platformGraphics = options.CustomPlatformGraphics
                                    ?? Win32GlManager.Initialize();
             
@@ -205,67 +203,15 @@ namespace Avalonia.Win32
             }
         }
 
-        public void RunLoop(CancellationToken cancellationToken)
-        {
-            var result = 0;
-            while (!cancellationToken.IsCancellationRequested 
-                && (result = GetMessage(out var msg, IntPtr.Zero, 0, 0)) > 0)
-            {
-                TranslateMessage(ref msg);
-                DispatchMessage(ref msg);
-            }
-            if (result < 0)
-            {
-                Logging.Logger.TryGet(Logging.LogEventLevel.Error, Logging.LogArea.Win32Platform)
-                    ?.Log(this, "Unmanaged error in {0}. Error Code: {1}", nameof(RunLoop), Marshal.GetLastWin32Error());
-            }
-        }
-
-        public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action callback)
-        {
-            TimerProc timerDelegate = (_, _, _, _) => callback();
-
-            IntPtr handle = SetTimer(
-                IntPtr.Zero,
-                IntPtr.Zero,
-                (uint)interval.TotalMilliseconds,
-                timerDelegate);
-
-            // Prevent timerDelegate being garbage collected.
-            _delegates.Add(timerDelegate);
-
-            return Disposable.Create(() =>
-            {
-                _delegates.Remove(timerDelegate);
-                KillTimer(IntPtr.Zero, handle);
-            });
-        }
-
-        private const int SignalW = unchecked((int)0xdeadbeaf);
-        private const int SignalL = unchecked((int)0x12345678);
-
-        public void Signal(DispatcherPriority prio)
-        {
-            PostMessage(
-                _hwnd,
-                (int)WindowsMessage.WM_DISPATCH_WORK_ITEM,
-                new IntPtr(SignalW),
-                new IntPtr(SignalL));
-        }
-
-        public bool CurrentThreadIsLoopThread => s_uiThread == Thread.CurrentThread;
-
-        public event Action<DispatcherPriority?>? Signaled;
-
         public event EventHandler<ShutdownRequestedEventArgs>? ShutdownRequested;
 
         [SuppressMessage("Microsoft.StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Justification = "Using Win32 naming for consistency.")]
         private IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
         {
-            if (msg == (int)WindowsMessage.WM_DISPATCH_WORK_ITEM && wParam.ToInt64() == SignalW && lParam.ToInt64() == SignalL)
-            {
-                Signaled?.Invoke(null);
-            }
+            if (msg == (int)WindowsMessage.WM_DISPATCH_WORK_ITEM 
+                && wParam.ToInt64() == Win32DispatcherImpl.SignalW 
+                && lParam.ToInt64() == Win32DispatcherImpl.SignalL) 
+                _dispatcher?.DispatchWorkItem();
 
             if(msg == (uint)WindowsMessage.WM_QUERYENDSESSION)
             {

tests/Avalonia.Base.UnitTests/Composition/CompositionAnimationTests.cs

@@ -62,13 +62,24 @@ public class CompositionAnimationTests
             }
         }
     }
+
+    class DummyDispatcher : IDispatcher
+    {
+        public bool CheckAccess() => true;
+
+        public void VerifyAccess()
+        {
+        }
+
+        public void Post(Action action, DispatcherPriority priority = default) => throw new NotSupportedException();
+    }
     
     [AnimationDataProvider]
     [Theory]
     public void GenericCheck(AnimationData data)
     {
         var compositor =
-            new Compositor(new RenderLoop(new CompositorTestServices.ManualRenderTimer(), new Dispatcher(null)), null);
+            new Compositor(new RenderLoop(new CompositorTestServices.ManualRenderTimer(), new DummyDispatcher()), null);
         var target = compositor.CreateSolidColorVisual();
         var ani = new ScalarKeyFrameAnimation(null);
         foreach (var frame in data.Frames)

tests/Avalonia.Base.UnitTests/DispatcherTests.cs

@@ -0,0 +1,180 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Threading;
+using Xunit;
+namespace Avalonia.Base.UnitTests;
+
+public class DispatcherTests
+{
+    class SimpleDispatcherImpl : IDispatcherImpl, IDispatcherClock, IDispatcherImplWithPendingInput
+    {
+        public bool CurrentThreadIsLoopThread => true;
+
+        public void Signal() => AskedForSignal = true;
+
+        public event Action Signaled;
+        public event Action Timer;
+        public int? NextTimer { get; private set; }
+        public bool AskedForSignal { get; private set; }
+        
+        public void UpdateTimer(int? dueTimeInTicks)
+        {
+            NextTimer = dueTimeInTicks;
+        }
+
+        public int TickCount { get; set; }
+
+        public void ExecuteSignal()
+        {
+            if (!AskedForSignal)
+                return;
+            AskedForSignal = false;
+            Signaled?.Invoke();
+        }
+
+        public void ExecuteTimer()
+        {
+            if (NextTimer == null)
+                return;
+            TickCount = NextTimer.Value;
+            Timer?.Invoke();
+        }
+
+        public bool CanQueryPendingInput => TestInputPending != null;
+        public bool HasPendingInput => TestInputPending == true;
+        public bool? TestInputPending { get; set; }
+    }
+    
+    
+    [Fact]
+    public void DispatcherExecutesJobsAccordingToPriority()
+    {
+        var impl = new SimpleDispatcherImpl();
+        var disp = new Dispatcher(impl, impl);
+        var actions = new List<string>();
+        disp.Post(()=>actions.Add("Background"), DispatcherPriority.Background);
+        disp.Post(()=>actions.Add("Render"), DispatcherPriority.Render);
+        disp.Post(()=>actions.Add("Input"), DispatcherPriority.Input);
+        Assert.True(impl.AskedForSignal);
+        impl.ExecuteSignal();
+        Assert.Equal(new[] { "Render", "Input", "Background" }, actions);
+    }
+    
+    [Fact]
+    public void DispatcherPreservesOrderWhenChangingPriority()
+    {
+        var impl = new SimpleDispatcherImpl();
+        var disp = new Dispatcher(impl, impl);
+        var actions = new List<string>();
+        var toPromote = disp.InvokeAsync(()=>actions.Add("PromotedRender"), DispatcherPriority.Background);
+        var toPromote2 = disp.InvokeAsync(()=>actions.Add("PromotedRender2"), DispatcherPriority.Input);
+        disp.Post(() => actions.Add("Render"), DispatcherPriority.Render);
+        
+        toPromote.Priority = DispatcherPriority.Render;
+        toPromote2.Priority = DispatcherPriority.Render;
+        
+        Assert.True(impl.AskedForSignal);
+        impl.ExecuteSignal();
+        
+        Assert.Equal(new[] { "PromotedRender", "PromotedRender2", "Render" }, actions);
+    }
+
+    [Fact]
+    public void DispatcherStopsItemProcessingWhenInteractivityDeadlineIsReached()
+    {
+        var impl = new SimpleDispatcherImpl();
+        var disp = new Dispatcher(impl, impl);
+        var actions = new List<int>();
+        for (var c = 0; c < 10; c++)
+        {
+            var itemId = c;
+            disp.Post(() =>
+            {
+                actions.Add(itemId);
+                impl.TickCount += 20;
+            }, DispatcherPriority.Background);
+        }
+
+        Assert.False(impl.AskedForSignal);
+        Assert.NotNull(impl.NextTimer);
+
+        impl.ExecuteTimer();
+        Assert.True(impl.AskedForSignal);
+        Assert.Null(impl.NextTimer);
+
+        for (var c = 0; c < 4; c++)
+        {
+            if (impl.NextTimer != null)
+                impl.ExecuteTimer();
+            Assert.True(impl.AskedForSignal);
+            impl.ExecuteSignal();
+            var expectedCount = (c + 1) * 3;
+            if (c == 3)
+                expectedCount = 10;
+            
+            Assert.Equal(Enumerable.Range(0, expectedCount), actions);
+            Assert.False(impl.AskedForSignal);
+            if (c < 3)
+            {
+                Assert.True(impl.NextTimer > impl.TickCount);
+            }
+            else
+                Assert.Null(impl.NextTimer);
+        }
+    }
+    
+    
+    [Fact]
+    public void DispatcherStopsItemProcessingWhenInputIsPending()
+    {
+        var impl = new SimpleDispatcherImpl();
+        impl.TestInputPending = false;
+        var disp = new Dispatcher(impl, impl);
+        var actions = new List<int>();
+        for (var c = 0; c < 10; c++)
+        {
+            var itemId = c;
+            disp.Post(() =>
+            {
+                actions.Add(itemId);
+                if (itemId == 0 || itemId == 3 || itemId == 7)
+                    impl.TestInputPending = true;
+            }, DispatcherPriority.Background);
+        }
+        Assert.False(impl.AskedForSignal);
+        Assert.NotNull(impl.NextTimer);
+
+        impl.ExecuteTimer();
+        Assert.True(impl.AskedForSignal);
+        Assert.Null(impl.NextTimer);
+
+        for (var c = 0; c < 4; c++)
+        {
+            if (impl.NextTimer != null)
+                impl.ExecuteTimer();
+            Assert.True(impl.AskedForSignal);
+            impl.ExecuteSignal();
+            var expectedCount = c switch
+            {
+                0 => 1,
+                1 => 4,
+                2 => 8,
+                3 => 10
+            };
+            
+            Assert.Equal(Enumerable.Range(0, expectedCount), actions);
+            Assert.False(impl.AskedForSignal);
+            if (c < 3)
+            {
+                Assert.True(impl.NextTimer > impl.TickCount);
+                impl.TickCount = impl.NextTimer.Value + 1;
+            }
+            else
+                Assert.Null(impl.NextTimer);
+
+            impl.TestInputPending = false;
+        }
+    }
+    
+}

tests/Avalonia.Base.UnitTests/Rendering/RenderLoopTests.cs

@@ -47,9 +47,8 @@ namespace Avalonia.Base.UnitTests.Rendering
         {
             var dispatcher = new Mock<IDispatcher>();
             dispatcher.Setup(
-                d => d.InvokeAsync(It.IsAny<Action>(), DispatcherPriority.Render))
-                .Callback((Action a, DispatcherPriority _) => a())
-                .Returns(Task.CompletedTask);
+                    d => d.Post(It.IsAny<Action>(), DispatcherPriority.Render))
+                .Callback((Action a, DispatcherPriority _) => a());
 
             var timer = new Mock<IRenderTimer>();
             var loop = new RenderLoop(timer.Object, dispatcher.Object);

tests/Avalonia.Controls.UnitTests/ToolTipTests.cs

@@ -157,7 +157,7 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
-        [Fact]
+        [Fact(Skip = "Timers should NOT, in fact, be checked via IPlatformThreadingInterface")]
         public void Should_Open_On_Pointer_Enter_With_Delay()
         {
             Action timercallback = null;

tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Xml;
 using Avalonia.Controls;
 using Avalonia.Markup.Xaml.Styling;

tests/Avalonia.Markup.Xaml.UnitTests/XamlTestBase.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
 using System.Text;
+using Avalonia.Controls;
 using Avalonia.Data;
 
 namespace Avalonia.Markup.Xaml.UnitTests
@@ -13,6 +14,7 @@ namespace Avalonia.Markup.Xaml.UnitTests
         {
             // Ensure necessary assemblies are loaded.
             var _ = typeof(TemplateBinding);
+            GC.KeepAlive(typeof(ItemsRepeater));
             if (AvaloniaLocator.Current.GetService<AvaloniaXamlLoader.IRuntimeXamlLoader>() == null)
                 AvaloniaLocator.CurrentMutable.Bind<AvaloniaXamlLoader.IRuntimeXamlLoader>()
                     .ToConstant(new TestXamlLoaderShim());

tests/Avalonia.UnitTests/UnitTestApplication.cs

@@ -43,7 +43,7 @@ namespace Avalonia.UnitTests
         {
             var scope = AvaloniaLocator.EnterScope();
             var app = new UnitTestApplication(services);
-            Dispatcher.UIThread.UpdateServices();
+            Dispatcher.ResetForUnitTests();
             return Disposable.Create(() =>
             {
                 if (Dispatcher.UIThread.CheckAccess())
@@ -52,7 +52,7 @@ namespace Avalonia.UnitTests
                 }
 
                 scope.Dispose();
-                Dispatcher.UIThread.UpdateServices();
+                Dispatcher.ResetForUnitTests();
             });
         }