@@ -1734,54 +1734,68 @@ internal void ResetCancellation()
     internal void PerformUserCancellation()
     {
         var connection = Connection;
-        if (connection is null || connection.ConnectorBindingScope == ConnectorBindingScope.Reader)
+        if (connection is null || connection.ConnectorBindingScope == ConnectorBindingScope.Reader || UserCancellationRequested)
             return;
 
-        // Take the lock first to make sure there is no concurrent Break.
-        // We should be safe to take it as Break only take it to set the state.
-        lock (SyncObj)
+        // Run the cancellation on a threadpool
+        // Because PerformUserCancellation is used as a callback for CancellationToken, which can trigger synchronously
+        // And this can lead to a deadlock
+        // See #5032
+        Task.Run(() =>
         {
-            // The connector is dead, exit gracefully.
-            if (!IsConnected)
-                return;
-            // The connector is still alive, take the CancelLock before exiting SingleUseLock.
-            // If a break will happen after, it's going to wait for the cancellation to complete.
-            Monitor.Enter(CancelLock);
-        }
-
-        // Wait before we've read all responses for the prepended queries
-        // as we can't gracefully handle their cancellation.
-        // Break makes sure that it's going to be set even if we fail while reading them.
-        ReadingPrependedMessagesMRE.Wait();
+            try
+            {
+                // Take the lock first to make sure there is no concurrent Break.
+                // We should be safe to take it as Break only take it to set the state.
+                lock (SyncObj)
+                {
+                    // The connector is dead, exit gracefully.
+                    if (!IsConnected)
+                        return;
+                    // The connector is still alive, take the CancelLock before exiting SingleUseLock.
+                    // If a break will happen after, it's going to wait for the cancellation to complete.
+                    Monitor.Enter(CancelLock);
+                }
 
-        try
-        {
-            _userCancellationRequested = true;
+                // Wait before we've read all responses for the prepended queries
+                // as we can't gracefully handle their cancellation.
+                // Break makes sure that it's going to be set even if we fail while reading them.
+                ReadingPrependedMessagesMRE.Wait();
 
-            if (AttemptPostgresCancellation && SupportsPostgresCancellation)
-            {
-                var cancellationTimeout = Settings.CancellationTimeout;
-                if (PerformPostgresCancellation() && cancellationTimeout >= 0)
+                try
                 {
-                    if (cancellationTimeout > 0)
+                    _userCancellationRequested = true;
+
+                    if (AttemptPostgresCancellation && SupportsPostgresCancellation)
                     {
-                        UserTimeout = cancellationTimeout;
-                        ReadBuffer.Timeout = TimeSpan.FromMilliseconds(cancellationTimeout);
-                        ReadBuffer.Cts.CancelAfter(cancellationTimeout);
+                        var cancellationTimeout = Settings.CancellationTimeout;
+                        if (PerformPostgresCancellation() && cancellationTimeout >= 0)
+                        {
+                            if (cancellationTimeout > 0)
+                            {
+                                UserTimeout = cancellationTimeout;
+                                ReadBuffer.Timeout = TimeSpan.FromMilliseconds(cancellationTimeout);
+                                ReadBuffer.Cts.CancelAfter(cancellationTimeout);
+                            }
+
+                            return;
+                        }
                     }
 
-                    return;
+                    UserTimeout = -1;
+                    ReadBuffer.Timeout = _cancelImmediatelyTimeout;
+                    ReadBuffer.Cts.Cancel();
+                }
+                finally
+                {
+                    Monitor.Exit(CancelLock);
                 }
             }
-
-            UserTimeout = -1;
-            ReadBuffer.Timeout = _cancelImmediatelyTimeout;
-            ReadBuffer.Cts.Cancel();
-        }
-        finally
-        {
-            Monitor.Exit(CancelLock);
-        }
+            catch
+            {
+                // Ignore
+            }
+        });
     }
 
     /// <summary>