Пример #1
0
        public T BorrowObject(long borrowMaxWaitMillis)
        {
            AssertOpen();

            AbandonedConfig ac = this.abandonedConfig;

            if (ac != null && ac.getRemoveAbandonedOnBorrow() &&
                (GetNumIdle() < 2) &&
                (GetNumActive() > GetMaxTotal() - 3))
            {
                RemoveAbandoned(ac);
            }

            IPooledObject <T> p = null;

            // Get local copy of current config so it is consistent for entire
            // method execution
            bool blockWhenExhausted = getBlockWhenExhausted();

            bool create;
            long waitTime = DateTime.Now.CurrentTimeMillis();

            while (p == null)
            {
                create = false;
                if (blockWhenExhausted)
                {
                    p = idleObjects.RemoveFront();
                    if (p == null)
                    {
                        p = Create();
                        if (p != null)
                        {
                            create = true;
                        }
                    }
                    if (p == null)
                    {
                        if (borrowMaxWaitMillis < 0)
                        {
                            p = idleObjects.First();
                        }
                        else
                        {
                            p = idleObjects.RemoveFront();
                        }
                    }
                    if (p == null)
                    {
                        throw new Exception(
                                  "Timeout waiting for idle object");
                    }
                    if (!p.Allocate())
                    {
                        p = null;
                    }
                }
                else
                {
                    p = idleObjects.RemoveFront();
                    if (p == null)
                    {
                        p = Create();
                        if (p != null)
                        {
                            create = true;
                        }
                    }
                    if (p == null)
                    {
                        throw new Exception("Pool exhausted");
                    }
                    if (!p.Allocate())
                    {
                        p = null;
                    }
                }

                if (p != null)
                {
                    try {
                        factory.ActivateObject(p);
                    } catch (Exception e) {
                        try {
                            Destroy(p);
                        } catch (Exception e1) {
                            // Ignore - activation failure is more important
                        }
                        p = null;
                        if (create)
                        {
                            throw new Exception("Unable to activate object");
                        }
                    }
                    if (p != null && (GetTestOnBorrow() || create && getTestOnCreate()))
                    {
                        bool validate = false;
                        // Throwable validationThrowable = null;
                        try {
                            validate = factory.ValidateObject(p);
                        } catch (Exception t)
                        {
                            throw t;
                            //   validationThrowable = t;
                        }
                        if (!validate)
                        {
                            try {
                                Destroy(p);
                            } catch (Exception e) {
                                // Ignore - validation failure is more important
                            }
                            p = null;
                            if (create)
                            {
                                throw new Exception("Unable to activate object");
                            }
                        }
                    }
                }
            }

            UpdateStatsBorrow(p, DateTime.Now.CurrentTimeMillis() - waitTime);

            return(p.GetObject());
        }
Пример #2
0
        private T BorrowObject(K key, long borrowMaxWaitMillis)
        {
            AssertOpen();
            IPooledObject <T> p = null;

            // Get local copy of current config so it is consistent for entire
            // method execution
            bool blockWhenExhausted = getBlockWhenExhausted();

            bool            create;
            long            waitTime    = DateTime.Now.CurrentTimeMillis();
            ObjectDeque <T> objectDeque = Register(key);

            try
            {
                while (p == null)
                {
                    create = false;
                    if (blockWhenExhausted)
                    {
                        p = objectDeque.GetIdleObjects().RemoveFront();
                        if (p == null)
                        {
                            p = Create(key);
                            if (p != null)
                            {
                                create = true;
                            }
                        }
                        if (p == null)
                        {
                            if (borrowMaxWaitMillis < 0)
                            {
                                p = objectDeque.GetIdleObjects().TakeFront();
                            }
                            else
                            {
                                p = objectDeque.GetIdleObjects().RemoveFront();
                            }
                        }
                        if (p == null)
                        {
                            throw new Exception(
                                      "Timeout waiting for idle object");
                        }
                        if (!p.Allocate())
                        {
                            p = null;
                        }
                    }
                    else
                    {
                        p = objectDeque.GetIdleObjects().RemoveFront();
                        if (p == null)
                        {
                            p = Create(key);
                            if (p != null)
                            {
                                create = true;
                            }
                        }
                        if (p == null)
                        {
                            throw new Exception("Pool exhausted");
                        }
                        if (!p.Allocate())
                        {
                            p = null;
                        }
                    }
                    if (p != null)
                    {
                        try
                        {
                            factory.ActivateObject(key, p);
                        }
                        catch (Exception e)
                        {
                            try
                            {
                                Destroy(key, p, true);
                            }
                            catch (Exception)
                            {
                                // ignore
                            }
                            p = null;
                            if (create)
                            {
                                throw new Exception("Unable to activate object");
                            }
                        }
                        if (p != null && (GetTestOnBorrow() || create && getTestOnCreate()))
                        {
                            bool validate = false;
                            try
                            {
                                validate = factory.ValidateObject(key, p);
                            }
                            catch (Exception)
                            {
                                throw;
                            }
                            if (!validate)
                            {
                                try
                                {
                                    Destroy(key, p, true);
                                    destroyedByBorrowValidationCount++;
                                }
                                catch (Exception)
                                {
                                    // Ignore - validation failure is more important
                                }
                                p = null;
                                if (create)
                                {
                                    throw new Exception("Unable to validate object");
                                }
                            }
                        }
                    }
                }
            }
            finally
            {
                Deregister(key);
            }
            UpdateStatsBorrow(p, DateTime.Now.CurrentTimeMillis() - waitTime);
            return(p.GetObject());
        }