# HG changeset patch
# User cin
# Date 2013-11-13 10:03:20
# Node ID f0568ff069a51973c64a7a6093b48c751a6cb198
# Parent  0c924dff549845e943fccd50adc8239c1930f758
# Parent  5a35900264f5d7a3e7a5adf452791da58790804d

Слияние с promises

diff --git a/Implab.Test/AsyncTests.cs b/Implab.Test/AsyncTests.cs
--- a/Implab.Test/AsyncTests.cs
+++ b/Implab.Test/AsyncTests.cs
@@ -14,7 +14,7 @@ namespace Implab.Test {
             p.Then(x => res = x);
             p.Resolve(100);
 
-            Assert.AreEqual(res, 100);
+            Assert.AreEqual(100, res);
         }
 
         [TestMethod]
@@ -101,18 +101,18 @@ namespace Implab.Test {
         public void WorkerPoolSizeTest() {
             var pool = new WorkerPool(5, 10, 0);
 
-            Assert.AreEqual(5, pool.ThreadCount);
+            Assert.AreEqual(5, pool.PoolSize);
 
-            pool.Invoke(() => { Thread.Sleep(1000000); return 10; });
-            pool.Invoke(() => { Thread.Sleep(1000000); return 10; });
-            pool.Invoke(() => { Thread.Sleep(1000000); return 10; });
+            pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
+            pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
+            pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
 
-            Assert.AreEqual(5, pool.ThreadCount);
+            Assert.AreEqual(5, pool.PoolSize);
 
             for (int i = 0; i < 100; i++)
-                pool.Invoke(() => { Thread.Sleep(1000000); return 10; });
-            Thread.Sleep(100);
-            Assert.AreEqual(10, pool.ThreadCount);
+                pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
+            Thread.Sleep(200);
+            Assert.AreEqual(10, pool.PoolSize);
 
             pool.Dispose();
         }
@@ -149,10 +149,10 @@ namespace Implab.Test {
         [TestMethod]
         public void WorkerPoolDisposeTest() {
             var pool = new WorkerPool(5, 20);
-            Assert.AreEqual(5, pool.ThreadCount);
+            Assert.AreEqual(5, pool.PoolSize);
             pool.Dispose();
-            Thread.Sleep(100);
-            Assert.AreEqual(0, pool.ThreadCount);
+            Thread.Sleep(500);
+            Assert.AreEqual(0, pool.PoolSize);
             pool.Dispose();
         }
 
@@ -244,7 +244,7 @@ namespace Implab.Test {
         [TestMethod]
         public void ChainedMapTest() {
 
-            using (var pool = new WorkerPool(8,100,0)) {
+            using (var pool = new WorkerPool(4,4,0)) {
                 int count = 10000;
 
                 double[] args = new double[count];
diff --git a/Implab.suo b/Implab.suo
index 453df4ad2d602dd29c42a1de303bdb9f56e12f58..2e658bab65aab728cc1f2d27570c91f2140bb05f
GIT binary patch
literal 75264
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
P(K(!2kXd0N!gT*1Qma<E

diff --git a/Implab.v11.suo b/Implab.v11.suo
index 0324d71b1911ff2672c0c8ae7c7d19bceabeae2e..1a41f7b2d0cb05a0444b1048004dea186d59b1e0
GIT binary patch
literal 115712
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
R&BLz{lE(+E*!&;q@c(`>ykr0X

diff --git a/Implab/IPromise.cs b/Implab/IPromise.cs
--- a/Implab/IPromise.cs
+++ b/Implab/IPromise.cs
@@ -15,19 +15,6 @@ namespace Implab
             get;
         }
 
-        /// <summary>
-        /// The current state of the promise.
-        /// </summary>
-        PromiseState State
-        {
-            get;
-        }
 
-        /// <summary>
-        /// Registers handler for the case when the promise is cencelled. If the promise already cancelled the
-        /// handler will be invoked immediatelly.
-        /// </summary>
-        /// <param name="handler">The handler</param>
-        void HandleCancelled(Action handler);
     }
 }
diff --git a/Implab/Parallels/ArrayTraits.cs b/Implab/Parallels/ArrayTraits.cs
--- a/Implab/Parallels/ArrayTraits.cs
+++ b/Implab/Parallels/ArrayTraits.cs
@@ -140,7 +140,7 @@ namespace Implab.Parallels {
 
             AsyncPool.InvokeNewThread(() => {
                 for (int i = 0; i < source.Length; i++) {
-                    if(promise.State != PromiseState.Unresolved)
+                    if(promise.IsResolved)
                         break; // stop processing in case of error or cancellation
                     var idx = i;
                     semaphore.WaitOne();
diff --git a/Implab/Parallels/DispatchPool.cs b/Implab/Parallels/DispatchPool.cs
--- a/Implab/Parallels/DispatchPool.cs
+++ b/Implab/Parallels/DispatchPool.cs
@@ -9,10 +9,15 @@ namespace Implab.Parallels {
     public abstract class DispatchPool<TUnit> : IDisposable {
         readonly int m_minThreads;
         readonly int m_maxThreads;
-        int m_runningThreads = 0;
-        int m_maxRunningThreads = 0;
-        int m_suspended = 0;
-        int m_exitRequired = 0;
+
+        int m_createdThreads = 0; // the current size of the pool
+        int m_activeThreads = 0; // the count of threads which are active
+        int m_sleepingThreads = 0; // the count of currently inactive threads
+        int m_maxRunningThreads = 0; // the meximum reached size of the pool
+        int m_exitRequired = 0; // the pool is going to shutdown, all unused workers are released
+        int m_releaseTimeout = 100; // the timeout while the working thread will wait for the new tasks before exit
+        int m_wakeEvents = 0; // the count of wake events
+        
         AutoResetEvent m_hasTasks = new AutoResetEvent(false);
 
         protected DispatchPool(int min, int max) {
@@ -44,9 +49,15 @@ namespace Implab.Parallels {
                 StartWorker();
         }
 
-        public int ThreadCount {
+        public int PoolSize {
             get {
-                return m_runningThreads;
+                return m_createdThreads;
+            }
+        }
+
+        public int ActiveThreads {
+            get {
+                return m_activeThreads;
             }
         }
 
@@ -64,29 +75,120 @@ namespace Implab.Parallels {
 
         protected abstract bool TryDequeue(out TUnit unit);
 
-        protected virtual bool ExtendPool() {
-            if (m_suspended > 0) {
+        #region thread execution traits
+        int SignalThread() {
+            var signals = Interlocked.Increment(ref m_wakeEvents);
+            if(signals == 1)
                 m_hasTasks.Set();
+            return signals;
+        }
+
+        bool FetchSignalOrWait(int timeout) {
+            var start = Environment.TickCount;
+
+            // означает, что поток владеет блокировкой и при успешном получении сигнала должен
+            // ее вернуть, чтобы другой ожидающий поток смог 
+            bool hasLock = false;
+            do {
+                int signals;
+                do {
+                    signals = m_wakeEvents;
+                    if (signals == 0)
+                        break;
+                } while (Interlocked.CompareExchange(ref m_wakeEvents, signals - 1, signals) != signals);
+
+                if (signals >= 1) {
+                    if (signals > 1 && hasLock)
+                        m_hasTasks.Set();
+                    return true;
+                }
+                
+                if (timeout != -1)
+                    timeout = Math.Max(0, timeout - (Environment.TickCount - start));
+
+                // если сигналов больше не осталось, то первый поток, который дошел сюда сбросит событие
+                // и уйдет на пустой цикл, после чего заблокируется
+
+                hasLock = true; 
+            } while (m_hasTasks.WaitOne(timeout));
+
+            return false;
+        }
+
+        bool Sleep(int timeout) {
+            Interlocked.Increment(ref m_sleepingThreads);
+            if (FetchSignalOrWait(timeout)) {
+                Interlocked.Decrement(ref m_sleepingThreads);
                 return true;
-            } else
-                return StartWorker();
+            } else {
+                Interlocked.Decrement(ref m_sleepingThreads);
+                return false;
+            }
         }
+        #endregion
 
         /// <summary>
         /// Запускает либо новый поток, если раньше не было ни одного потока, либо устанавливает событие пробуждение одного спящего потока
         /// </summary>
-        protected void WakePool() {
-            m_hasTasks.Set(); // wake sleeping thread;
+        protected void GrowPool() {
+            if (m_exitRequired != 0)
+                return;
+            if (m_sleepingThreads > m_wakeEvents) {
+                //Console.WriteLine("Waking threads (sleeps {0}, pending {1})", m_sleepingThreads, m_wakeEvents);
+
+                // all sleeping threads may gone
+                SignalThread(); // wake a sleeping thread;
 
-            if (AllocateThreadSlot(1)) {
-                var worker = new Thread(this.Worker);
-                worker.IsBackground = true;
-                worker.Start();
+                // we can't check whether signal has been processed
+                // anyway it may take some time for the thread to start
+                // we will ensure that at least one thread is running
+
+                if (AllocateThreadSlot(1)) {
+                    // if there were no threads in the pool
+                    var worker = new Thread(this.Worker);
+                    worker.IsBackground = true;
+                    worker.Start();
+                }
+            } else {
+                // if there is no sleeping threads in the pool
+                StartWorker();
             }
         }
 
-        protected virtual void Suspend() {
-            m_hasTasks.WaitOne();
+        private bool Suspend() {
+            //no tasks left, exit if the thread is no longer needed
+            bool last;
+            bool requestExit;
+
+            // if threads have a timeout before releasing
+            if (m_releaseTimeout > 0)
+                requestExit = !Sleep(m_releaseTimeout);
+            else
+                requestExit = true;
+
+            if (!requestExit)
+                return true;
+
+            // release unsused thread
+            if (requestExit && ReleaseThreadSlot(out last)) {
+                // in case at the moment the last thread was being released
+                // a new task was added to the queue, we need to try
+                // to revoke the thread to avoid the situation when the task is left unprocessed
+                if (last && Sleep(0)) { // Sleep(0) will fetch pending task or will return false
+                    if (AllocateThreadSlot(1))
+                        return true; // spin again...
+                    else
+                        SignalThread(); // since Sleep(0) has fetched the signal we neet to reschedule it
+                    
+                }
+
+                return false;
+            }
+
+            // wait till infinity
+            Sleep(-1);
+
+            return true;
         }
 
         #region thread slots traits
@@ -95,11 +197,11 @@ namespace Implab.Parallels {
             int current;
             // use spins to allocate slot for the new thread
             do {
-                current = m_runningThreads;
+                current = m_createdThreads;
                 if (current >= m_maxThreads || m_exitRequired != 0)
                     // no more slots left or the pool has been disposed
                     return false;
-            } while (current != Interlocked.CompareExchange(ref m_runningThreads, current + 1, current));
+            } while (current != Interlocked.CompareExchange(ref m_createdThreads, current + 1, current));
 
             UpdateMaxThreads(current + 1);
 
@@ -107,7 +209,7 @@ namespace Implab.Parallels {
         }
 
         bool AllocateThreadSlot(int desired) {
-            if (desired - 1 != Interlocked.CompareExchange(ref m_runningThreads, desired, desired - 1))
+            if (desired - 1 != Interlocked.CompareExchange(ref m_createdThreads, desired, desired - 1))
                 return false;
 
             UpdateMaxThreads(desired);
@@ -120,11 +222,11 @@ namespace Implab.Parallels {
             int current;
             // use spins to release slot for the new thread
             do {
-                current = m_runningThreads;
+                current = m_createdThreads;
                 if (current <= m_minThreads && m_exitRequired == 0)
                     // the thread is reserved
                     return false;
-            } while (current != Interlocked.CompareExchange(ref m_runningThreads, current - 1, current));
+            } while (current != Interlocked.CompareExchange(ref m_createdThreads, current - 1, current));
 
             last = (current == 1);
 
@@ -136,7 +238,7 @@ namespace Implab.Parallels {
         /// </summary>
         /// <returns>true - no more threads left</returns>
         bool ReleaseThreadSlotAnyway() {
-            var left = Interlocked.Decrement(ref m_runningThreads);
+            var left = Interlocked.Decrement(ref m_createdThreads);
             return left == 0;
         }
 
@@ -164,54 +266,41 @@ namespace Implab.Parallels {
             }
         }
 
-        bool FetchTask(out TUnit unit) {
+        protected abstract void InvokeUnit(TUnit unit);
+
+        void Worker() {
+            TUnit unit;
+            //Console.WriteLine("{0}: Active", Thread.CurrentThread.ManagedThreadId);
+            Interlocked.Increment(ref m_activeThreads);
             do {
                 // exit if requested
                 if (m_exitRequired != 0) {
                     // release the thread slot
+                    Interlocked.Decrement(ref m_activeThreads);
                     if (ReleaseThreadSlotAnyway()) // it was the last worker
                         m_hasTasks.Dispose();
                     else
-                        m_hasTasks.Set(); // wake next worker
+                        SignalThread(); // wake next worker
                     unit = default(TUnit);
-                    return false;
+                    break;
                 }
 
                 // fetch task
                 if (TryDequeue(out unit)) {
-                    ExtendPool();
-                    return true;
+                    InvokeUnit(unit);
+                    continue;
                 }
 
-                //no tasks left, exit if the thread is no longer needed
-                bool last;
-                if (ReleaseThreadSlot(out last)) {
-                    if (last && m_hasTasks.WaitOne(0)) {
-                        if (AllocateThreadSlot(1))
-                            continue; // spin again...
-                        else
-                            // we failed to reallocate slot for this thread
-                            // therefore we need to release the event
-                            m_hasTasks.Set(); 
-                    }
-
-                    return false;
-                }
+                Interlocked.Decrement(ref m_activeThreads);
 
                 // entering suspend state
-                Interlocked.Increment(ref m_suspended);
                 // keep this thread and wait                
-                Suspend();
-                Interlocked.Decrement(ref m_suspended);
+                if (!Suspend())
+                    break;
+                //Console.WriteLine("{0}: Awake", Thread.CurrentThread.ManagedThreadId);
+                Interlocked.Increment(ref m_activeThreads);
             } while (true);
-        }
-
-        protected abstract void InvokeUnit(TUnit unit);
-
-        void Worker() {
-            TUnit unit;
-            while (FetchTask(out unit))
-                InvokeUnit(unit);
+            //Console.WriteLine("{0}: Exited", Thread.CurrentThread.ManagedThreadId);
         }
 
         protected virtual void Dispose(bool disposing) {
@@ -221,7 +310,10 @@ namespace Implab.Parallels {
                         return;
 
                     // wake sleeping threads
-                    m_hasTasks.Set();
+                    if (m_createdThreads > 0)
+                        SignalThread();
+                    else
+                        m_hasTasks.Dispose();
                     GC.SuppressFinalize(this);
                 }
             }
diff --git a/Implab/Parallels/MTQueue.cs b/Implab/Parallels/MTQueue.cs
--- a/Implab/Parallels/MTQueue.cs
+++ b/Implab/Parallels/MTQueue.cs
@@ -42,12 +42,13 @@ namespace Implab.Parallels {
                 next = first.next;
                 if (next == null) {
                     // this is the last element,
-                    // then try to update tail
+                    // then try to update the tail
                     if (first != Interlocked.CompareExchange(ref m_last, null, first)) {
-                        // this is inconsistent situation which means that the queue is empty
+                        // this is a ace condition
                         if (m_last == null)
+                            // the queue is empty
                             return false;
-                        // tail has been changed, that means that we need to restart
+                        // tail has been changed, than we need to restart
                         continue; 
                     }
 
diff --git a/Implab/Parallels/WorkerPool.cs b/Implab/Parallels/WorkerPool.cs
--- a/Implab/Parallels/WorkerPool.cs
+++ b/Implab/Parallels/WorkerPool.cs
@@ -57,16 +57,8 @@ namespace Implab.Parallels {
             var len = Interlocked.Increment(ref m_queueLength);
             m_queue.Enqueue(unit);
 
-            if(!ExtendPool())
-                WakePool();
-        }
-
-        protected override bool ExtendPool() {
-            if (m_queueLength <= m_threshold*ThreadCount)
-                // in this case we are in active thread and it request for additional workers
-                // satisfy it only when queue is longer than threshold
-                return false;
-            return base.ExtendPool();
+            if (len > m_threshold*ActiveThreads)
+                GrowPool();
         }
 
         protected override bool TryDequeue(out Action unit) {
@@ -81,9 +73,5 @@ namespace Implab.Parallels {
             unit();
         }
 
-        protected override void Suspend() {
-            if (m_queueLength == 0)
-                base.Suspend();
-        }
     }
 }
diff --git a/Implab/Promise.cs b/Implab/Promise.cs
--- a/Implab/Promise.cs
+++ b/Implab/Promise.cs
@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Reflection;
 using System.Diagnostics;
 using System.Threading;
+using Implab.Parallels;
 
 namespace Implab {
 
@@ -48,24 +49,53 @@ namespace Implab {
     /// </remarks>
     public class Promise<T> : IPromise {
 
-        struct ResultHandlerInfo {
+        struct HandlerDescriptor {
             public ResultHandler<T> resultHandler;
             public ErrorHandler errorHandler;
+            public Action cancellHandler;
+
+            public void Resolve(T result) {
+                if (resultHandler != null)
+                    try {
+                        resultHandler(result);
+                    } catch (Exception e) {
+                        Reject(e);
+                    }
+            }
+
+            public void Reject(Exception err) {
+                if (errorHandler != null)
+                    try {
+                        errorHandler(err);
+                    } catch {
+                    }
+            }
+
+            public void Cancel() {
+                if (cancellHandler != null)
+                    try {
+                        cancellHandler();
+                    } catch {
+                    }
+            }
         }
 
+        const int UnresolvedSate = 0;
+        const int TransitionalState = 1;
+        const int ResolvedState = 2;
+        const int RejectedState = 3;
+        const int CancelledState = 4;
+
         readonly IPromise m_parent;
-
-        LinkedList<ResultHandlerInfo> m_resultHandlers = new LinkedList<ResultHandlerInfo>();
-        LinkedList<Action> m_cancelHandlers = new LinkedList<Action>();
+        readonly bool m_cancellable;
 
-        readonly object m_lock = new Object();
-        readonly bool m_cancellable;
         int m_childrenCount = 0;
-
-        PromiseState m_state;
+        int m_state;
         T m_result;
         Exception m_error;
 
+        readonly MTQueue<HandlerDescriptor> m_handlers = new MTQueue<HandlerDescriptor>();
+
         public Promise() {
             m_cancellable = true;
         }
@@ -73,8 +103,6 @@ namespace Implab {
         public Promise(IPromise parent, bool cancellable) {
             m_cancellable = cancellable;
             m_parent = parent;
-            if (parent != null)
-                parent.HandleCancelled(InternalCancel);
         }
 
         void InternalCancel() {
@@ -82,22 +110,39 @@ namespace Implab {
             Cancel(false);
         }
 
+        bool BeginTransit() {
+            return UnresolvedSate == Interlocked.CompareExchange(ref m_state, TransitionalState, UnresolvedSate);
+        }
+
+        void CompleteTransit(int state) {
+            if (TransitionalState != Interlocked.CompareExchange(ref m_state, state, TransitionalState))
+                throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");
+        }
+
+        public bool IsResolved {
+            get {
+                return m_state > 1;
+            }
+        }
+
+        public bool IsCancelled {
+            get {
+                return m_state == CancelledState;
+            }
+        }
+
         /// <summary>
         /// Выполняет обещание, сообщая об успешном выполнении.
         /// </summary>
         /// <param name="result">Результат выполнения.</param>
         /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
         public void Resolve(T result) {
-            lock (m_lock) {
-                if (m_state == PromiseState.Cancelled)
-                    return;
-                if (m_state != PromiseState.Unresolved)
-                    throw new InvalidOperationException("The promise is already resolved");
+            if (BeginTransit()) {
                 m_result = result;
-                m_state = PromiseState.Resolved;
-            }
-
-            OnStateChanged();
+                CompleteTransit(ResolvedState);
+                OnStateChanged();
+            } else if (m_state != CancelledState)
+                throw new InvalidOperationException("The promise is already resolved");
         }
 
         /// <summary>
@@ -111,16 +156,12 @@ namespace Implab {
         /// <param name="error">Исключение возникшее при выполнении операции</param>
         /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
         public void Reject(Exception error) {
-            lock (m_lock) {
-                if (m_state == PromiseState.Cancelled || m_state == PromiseState.Rejected)
-                    return;
-                if (m_state != PromiseState.Unresolved)
-                    throw new InvalidOperationException("The promise is already resolved");
+            if (BeginTransit()) {
                 m_error = error;
-                m_state = PromiseState.Rejected;
-            }
-
-            OnStateChanged();
+                CompleteTransit(RejectedState);
+                OnStateChanged();
+            } else if (m_state == ResolvedState)
+                throw new InvalidOperationException("The promise is already resolved");
         }
 
         /// <summary>
@@ -144,27 +185,27 @@ namespace Implab {
 
             var medium = new Promise<T>(this, true);
 
-            var handlerInfo = new ResultHandlerInfo();
-
+            ResultHandler<T> resultHandler;
             if (success != null)
-                handlerInfo.resultHandler = x => {
+                resultHandler = x => {
                     success(x);
                     medium.Resolve(x);
                 };
             else
-                handlerInfo.resultHandler = medium.Resolve;
+                resultHandler = medium.Resolve;
 
+            ErrorHandler errorHandler;
             if (error != null)
-                handlerInfo.errorHandler = x => {
+                errorHandler = x => {
                     try {
                         error(x);
                     } catch { }
                     medium.Reject(x);
                 };
             else
-                handlerInfo.errorHandler = medium.Reject;
+                errorHandler = medium.Reject;
 
-            AddHandler(handlerInfo);
+            AddHandler(resultHandler, errorHandler, medium.InternalCancel);
 
             return medium;
         }
@@ -182,27 +223,28 @@ namespace Implab {
 
             var medium = new Promise<T>(this, true);
 
-            var handlerInfo = new ResultHandlerInfo();
+            ResultHandler<T> resultHandler;
+            ErrorHandler errorHandler;
 
             if (success != null)
-                handlerInfo.resultHandler = x => {
+                resultHandler = x => {
                     success(x);
                     medium.Resolve(x);
                 };
             else
-                handlerInfo.resultHandler = medium.Resolve;
+                resultHandler = medium.Resolve;
 
             if (error != null)
-                handlerInfo.errorHandler = x => {
+                errorHandler = x => {
                     try {
                         medium.Resolve(error(x));
                     } catch { }
                     medium.Reject(x);
                 };
             else
-                handlerInfo.errorHandler = medium.Reject;
+                errorHandler = medium.Reject;
 
-            AddHandler(handlerInfo);
+            AddHandler(resultHandler, errorHandler, medium.InternalCancel);
 
             return medium;
         }
@@ -214,19 +256,17 @@ namespace Implab {
 
             var medium = new Promise<T>(this, true);
 
-            var handlerInfo = new ResultHandlerInfo();
-
+            ResultHandler<T> resultHandler;
+            
             if (success != null)
-                handlerInfo.resultHandler = x => {
+                resultHandler = x => {
                     success(x);
                     medium.Resolve(x);
                 };
             else
-                handlerInfo.resultHandler = medium.Resolve;
+                resultHandler = medium.Resolve;
 
-            handlerInfo.errorHandler = medium.Reject;
-
-            AddHandler(handlerInfo);
+            AddHandler(resultHandler, medium.Reject, medium.InternalCancel);
 
             return medium;
         }
@@ -249,15 +289,17 @@ namespace Implab {
 
             var medium = new Promise<T>(this, true);
 
-            AddHandler(new ResultHandlerInfo {
-                errorHandler = e => {
+            AddHandler(
+                null,
+                e => {
                     try {
                         medium.Resolve(handler(e));
                     } catch (Exception e2) {
                         medium.Reject(e2);
                     }
-                }
-            });
+                },
+                medium.InternalCancel
+            );
 
             return medium;
         }
@@ -268,8 +310,8 @@ namespace Implab {
 
             var medium = new Promise<T>();
 
-            AddHandler(new ResultHandlerInfo {
-                resultHandler = x => {
+            AddHandler(
+                x => {
                     // to avoid handler being called multiple times we handle exception by ourselfs
                     try {
                         handler();
@@ -278,13 +320,16 @@ namespace Implab {
                         medium.Reject(e);
                     }
                 },
-                errorHandler = x => {
+
+                e => {
                     try {
                         handler();
                     } catch { }
-                    medium.Reject(x);
-                }
-            });
+                    medium.Reject(e);
+                },
+
+                medium.InternalCancel
+            );
 
             return medium;
         }
@@ -304,17 +349,22 @@ namespace Implab {
             // создаем прицепленное обещание
             var chained = new Promise<TNew>();
 
-            AddHandler(new ResultHandlerInfo() {
-                resultHandler = result => chained.Resolve(mapper(result)),
-                errorHandler = delegate(Exception e) {
-                    if (error != null)
-                        try {
-                            error(e);
-                        } catch { }
-                    // в случае ошибки нужно передать исключение дальше по цепочке
-                    chained.Reject(e);
-                }
-            });
+            ResultHandler<T> resultHandler = result => chained.Resolve(mapper(result));
+            ErrorHandler errorHandler = delegate(Exception e) {
+                if (error != null)
+                    try {
+                        error(e);
+                    } catch { }
+                // в случае ошибки нужно передать исключение дальше по цепочке
+                chained.Reject(e);
+            };
+
+
+            AddHandler(
+                resultHandler,
+                errorHandler,
+                chained.InternalCancel
+            );
 
             return chained;
         }
@@ -341,27 +391,32 @@ namespace Implab {
             // передать через него результаты работы.
             var medium = new Promise<TNew>(this, true);
 
-            AddHandler(new ResultHandlerInfo {
-                resultHandler = delegate(T result) {
-                    if (medium.State == PromiseState.Cancelled)
-                        return;
+            ResultHandler<T> resultHandler = delegate(T result) {
+                if (medium.IsCancelled)
+                    return;
 
-                    var promise = chained(result);
+                var promise = chained(result);
 
-                    // notify chained operation that it's not needed
-                    medium.Cancelled(() => promise.Cancel());
-                    promise.Then(
-                        x => medium.Resolve(x),
-                        e => medium.Reject(e)
-                    );
-                },
-                errorHandler = delegate(Exception e) {
-                    if (error != null)
-                        error(e);
-                    // в случае ошибки нужно передать исключение дальше по цепочке
-                    medium.Reject(e);
-                }
-            });
+                // notify chained operation that it's not needed
+                medium.Cancelled(() => promise.Cancel());
+                promise.Then(
+                    x => medium.Resolve(x),
+                    e => medium.Reject(e)
+                );
+            };
+
+            ErrorHandler errorHandler = delegate(Exception e) {
+                if (error != null)
+                    error(e);
+                // в случае ошибки нужно передать исключение дальше по цепочке
+                medium.Reject(e);
+            };
+
+            AddHandler(
+                resultHandler,
+                errorHandler,
+                medium.InternalCancel
+            );
 
             return medium;
         }
@@ -371,19 +426,19 @@ namespace Implab {
         }
 
         public Promise<T> Cancelled(Action handler) {
-            if (handler == null)
-                return this;
-            lock (m_lock) {
-                if (m_state == PromiseState.Unresolved)
-                    m_cancelHandlers.AddLast(handler);
-                else if (m_state == PromiseState.Cancelled)
-                    handler();
-            }
+            AddHandler(null, null, handler);
             return this;
         }
 
-        public void HandleCancelled(Action handler) {
-            Cancelled(handler);
+        public Promise<T> Finally(Action handler) {
+            if (handler == null)
+                throw new ArgumentNullException("handler");
+            AddHandler(
+                x => handler(),
+                e => handler(),
+                handler
+            );
+            return this;
         }
 
         /// <summary>
@@ -415,15 +470,15 @@ namespace Implab {
             if (!evt.WaitOne(timeout, true))
                 throw new TimeoutException();
 
-            switch (State) {
-                case PromiseState.Resolved:
+            switch (m_state) {
+                case ResolvedState:
                     return m_result;
-                case PromiseState.Cancelled:
+                case CancelledState:
                     throw new OperationCanceledException();
-                case PromiseState.Rejected:
+                case RejectedState:
                     throw new TargetInvocationException(m_error);
                 default:
-                    throw new ApplicationException(String.Format("Invalid promise state {0}", State));
+                    throw new ApplicationException(String.Format("Invalid promise state {0}", m_state));
             }
         }
 
@@ -431,40 +486,45 @@ namespace Implab {
             return Join(Timeout.Infinite);
         }
 
-        void AddHandler(ResultHandlerInfo handler) {
-            bool invokeRequired = false;
+        void AddHandler(ResultHandler<T> success, ErrorHandler error, Action cancel) {
+            Interlocked.Increment(ref m_childrenCount);
+
+            HandlerDescriptor handler = new HandlerDescriptor {
+                resultHandler = success,
+                errorHandler = error,
+                cancellHandler = cancel
+            };
 
-            lock (m_lock) {
-                m_childrenCount++;
-                if (m_state == PromiseState.Unresolved) {
-                    m_resultHandlers.AddLast(handler);
-                } else
-                    invokeRequired = true;
+            bool queued;
+
+            if (!IsResolved) {
+                m_handlers.Enqueue(handler);
+                queued = true;
+            } else {
+                // the promise is in resolved state, just invoke the handled with minimum overhead
+                queued = false;
+                InvokeHandler(handler);
             }
 
-            // обработчики не должны блокировать сам объект
-            if (invokeRequired)
+            if (queued && IsResolved && m_handlers.TryDequeue(out handler))
+                // if the promise have been resolved while we was adding handler to the queue
+                // we can't guarantee that someone is still processing it
+                // therefore we will fetch a handler from the queue and execute it
+                // note that fetched handler may be not the one we have added
                 InvokeHandler(handler);
+
         }
 
-        void InvokeHandler(ResultHandlerInfo handler) {
+        void InvokeHandler(HandlerDescriptor handler) {
             switch (m_state) {
-                case PromiseState.Resolved:
-                    try {
-                        if (handler.resultHandler != null)
-                            handler.resultHandler(m_result);
-                    } catch (Exception e) {
-                        try {
-                            if (handler.errorHandler != null)
-                                handler.errorHandler(e);
-                        } catch { }
-                    }
+                case ResolvedState:
+                    handler.Resolve(m_result);
                     break;
-                case PromiseState.Rejected:
-                    try {
-                        if (handler.errorHandler != null)
-                            handler.errorHandler(m_error);
-                    } catch { }
+                case RejectedState:
+                    handler.Reject(m_error);
+                    break;
+                case CancelledState:
+                    handler.Cancel();
                     break;
                 default:
                     // do nothing
@@ -473,76 +533,31 @@ namespace Implab {
         }
 
         protected virtual void OnStateChanged() {
-            switch (m_state) {
-                case PromiseState.Resolved:
-                    foreach (var resultHandlerInfo in m_resultHandlers)
-                        try {
-                            if (resultHandlerInfo.resultHandler != null)
-                                resultHandlerInfo.resultHandler(m_result);
-                        } catch (Exception e) {
-                            try {
-                                if (resultHandlerInfo.errorHandler != null)
-                                    resultHandlerInfo.errorHandler(e);
-                            } catch { }
-                        }
-                    break;
-                case PromiseState.Cancelled:
-                    foreach (var cancelHandler in m_cancelHandlers)
-                        cancelHandler();
-                    break;
-                case PromiseState.Rejected:
-                    foreach (var resultHandlerInfo in m_resultHandlers)
-                        try {
-                            if (resultHandlerInfo.errorHandler != null)
-                                resultHandlerInfo.errorHandler(m_error);
-                        } catch { }
-                    break;
-                default:
-                    throw new InvalidOperationException(String.Format("Promise entered an invalid state {0}", m_state));
-            }
-
-            m_resultHandlers = null;
-            m_cancelHandlers = null;
+            HandlerDescriptor handler;
+            while (m_handlers.TryDequeue(out handler))
+                InvokeHandler(handler);
         }
 
 
 
         public bool IsExclusive {
             get {
-                lock (m_lock) {
-                    return m_childrenCount <= 1;
-                }
-            }
-        }
-
-        public PromiseState State {
-            get {
-                lock (m_lock) {
-                    return m_state;
-                }
+                return m_childrenCount <= 1;
             }
         }
 
         protected bool Cancel(bool dependencies) {
-            bool result;
-
-            lock (m_lock) {
-                if (m_state == PromiseState.Unresolved) {
-                    m_state = PromiseState.Cancelled;
-                    result = true;
-                } else {
-                    result = false;
-                }
-            }
-
-            if (result)
+            if (BeginTransit()) {
+                CompleteTransit(CancelledState);
                 OnStateChanged();
 
-            if (dependencies && m_parent != null && m_parent.IsExclusive) {
-                m_parent.Cancel();
+                if (dependencies && m_parent != null && m_parent.IsExclusive)
+                    m_parent.Cancel();
+
+                return true;
+            } else {
+                return false;
             }
-
-            return result;
         }
 
     }