asp.net mvc Session RedisSessionStateProvider锁的实现

最近项目用到了RedisSessionStateProvider来保存session，发现比内存session慢，后来慢慢了解，发现asp.net session是有锁的。我在文章 你的项目真的需要Session吗？ redis保存session性能怎么样？也提到一些观点，本来打算在那篇文章补充一些类容，后来想了一下，还是重写一个短文吧。有关session 管道流程大家 可以参考 Asp.net Session认识加强-Session究竟是如何存储你知道吗？

我们的mvc程序都是有路由信息，那么就离不开UrlRoutingModule 该code如下：

namespace System.Web.Routing {
    using System.Diagnostics;
    using System.Globalization;
    using System.Runtime.CompilerServices;
    using System.Web.Security;
 
    [TypeForwardedFrom("System.Web.Routing, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
    public class UrlRoutingModule : IHttpModule {
        private static readonly object _contextKey = new Object();
        private static readonly object _requestDataKey = new Object();
        private RouteCollection _routeCollection;
 
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly",
            Justification = "This needs to be settable for unit tests.")]
        public RouteCollection RouteCollection {
            get {
                if (_routeCollection == null) {
                    _routeCollection = RouteTable.Routes;
                }
                return _routeCollection;
            }
            set {
                _routeCollection = value;
            }
        }
 
        protected virtual void Dispose() {
        }
 
        protected virtual void Init(HttpApplication application) {
 
            //////////////////////////////////////////////////////////////////
            // Check if this module has been already addded
            if (application.Context.Items[_contextKey] != null) {
                return; // already added to the pipeline
            }
            application.Context.Items[_contextKey] = _contextKey;
 
            // Ideally we would use the MapRequestHandler event.  However, MapRequestHandler is not available
            // in II6 or IIS7 ISAPI Mode.  Instead, we use PostResolveRequestCache, which is the event immediately
            // before MapRequestHandler.  This allows use to use one common codepath for all versions of IIS.
            application.PostResolveRequestCache += OnApplicationPostResolveRequestCache;
        }
 
        private void OnApplicationPostResolveRequestCache(object sender, EventArgs e) {
            HttpApplication app = (HttpApplication)sender;
            HttpContextBase context = new HttpContextWrapper(app.Context);
            PostResolveRequestCache(context);
        }
 
        [Obsolete("This method is obsolete. Override the Init method to use the PostMapRequestHandler event.")]
        public virtual void PostMapRequestHandler(HttpContextBase context) {
            // Backwards compat with 3.5 which used to have code here to Rewrite the URL
        }
 
        public virtual void PostResolveRequestCache(HttpContextBase context) {
            // Match the incoming URL against the route table
            RouteData routeData = RouteCollection.GetRouteData(context);
 
            // Do nothing if no route found
            if (routeData == null) {
                return;
            }
 
            // If a route was found, get an IHttpHandler from the route's RouteHandler
            IRouteHandler routeHandler = routeData.RouteHandler;
            if (routeHandler == null) {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        SR.GetString(SR.UrlRoutingModule_NoRouteHandler)));
            }
 
            // This is a special IRouteHandler that tells the routing module to stop processing
            // routes and to let the fallback handler handle the request.
            if (routeHandler is StopRoutingHandler) {
                return;
            }
 
            RequestContext requestContext = new RequestContext(context, routeData);
 
            // Dev10 766875    Adding RouteData to HttpContext
            context.Request.RequestContext = requestContext;
 
            IHttpHandler httpHandler = routeHandler.GetHttpHandler(requestContext);
            if (httpHandler == null) {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentUICulture,
                        SR.GetString(SR.UrlRoutingModule_NoHttpHandler),
                        routeHandler.GetType()));
            }
 
            if (httpHandler is UrlAuthFailureHandler) {
                if (FormsAuthenticationModule.FormsAuthRequired) {
                    UrlAuthorizationModule.ReportUrlAuthorizationFailure(HttpContext.Current, this);
                    return;
                }
                else {
                    throw new HttpException(, SR.GetString(SR.Assess_Denied_Description3));
                }
            }
 
            // Remap IIS7 to our handler
            context.RemapHandler(httpHandler);
        }
 
        #region IHttpModule Members
        void IHttpModule.Dispose() {
            Dispose();
        }
 
        void IHttpModule.Init(HttpApplication application) {
            Init(application);
        }
        #endregion
    }
}

在PostResolveRequestCache方法中   IHttpHandler httpHandler = routeHandler.GetHttpHandler(requestContext); 这么一句。这里的routeHandler其实默认是MvcRouteHandler，所以智力其实是调用MvcRouteHandler的GetHttpHandler方法。

MvcRouteHandler的code：

// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
 
using System.Web.Mvc.Properties;
using System.Web.Routing;
using System.Web.SessionState;
 
namespace System.Web.Mvc
{
    public class MvcRouteHandler : IRouteHandler
    {
        private IControllerFactory _controllerFactory;
 
        public MvcRouteHandler()
        {
        }
 
        public MvcRouteHandler(IControllerFactory controllerFactory)
        {
            _controllerFactory = controllerFactory;
        }
 
        protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext)
        {
            requestContext.HttpContext.SetSessionStateBehavior(GetSessionStateBehavior(requestContext));
            return new MvcHandler(requestContext);
        }
 
        protected virtual SessionStateBehavior GetSessionStateBehavior(RequestContext requestContext)
        {
            string controllerName = (string)requestContext.RouteData.Values["controller"];
            if (String.IsNullOrWhiteSpace(controllerName))
            {
                throw new InvalidOperationException(MvcResources.MvcRouteHandler_RouteValuesHasNoController);
            }
 
            IControllerFactory controllerFactory = _controllerFactory ?? ControllerBuilder.Current.GetControllerFactory();
            return controllerFactory.GetControllerSessionBehavior(requestContext, controllerName);
        }
 
        #region IRouteHandler Members
 
        IHttpHandler IRouteHandler.GetHttpHandler(RequestContext requestContext)
        {
            return GetHttpHandler(requestContext);
        }
 
        #endregion
    }
}

在MvcRouteHandler中GetHttpHandler设置SessionStateBehavior：

protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext)
{
requestContext.HttpContext.SetSessionStateBehavior(GetSessionStateBehavior(requestContext));
return new MvcHandler(requestContext);
}

SessionStateBehavior的值默认来源于DefaultControllerFactory的GetControllerSessionBehavior方法，有SessionStateAttribute特性就取其值，否者默认的SessionStateBehavior.Default

 SessionStateBehavior IControllerFactory.GetControllerSessionBehavior(RequestContext requestContext, string controllerName)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            if (String.IsNullOrEmpty(controllerName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName");
            }
 
            Type controllerType = GetControllerType(requestContext, controllerName);
            return GetControllerSessionBehavior(requestContext, controllerType);
        }
 
        protected internal virtual SessionStateBehavior GetControllerSessionBehavior(RequestContext requestContext, Type controllerType)
        {
            if (controllerType == null)
            {
                return SessionStateBehavior.Default;
            }
 
            return _sessionStateCache.GetOrAdd(
                controllerType,
                type =>
                {
                    var attr = type.GetCustomAttributes(typeof(SessionStateAttribute), inherit: true)
                        .OfType<SessionStateAttribute>()
                        .FirstOrDefault();
 
                    return (attr != null) ? attr.Behavior : SessionStateBehavior.Default;
                });
        }

那么HttpContext.SetSessionStateBehavior方法又是如何实现的：

  internal SessionStateBehavior SessionStateBehavior { get; set; }
 
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate",
          Justification = "An internal property already exists. This method does additional work.")]
        public void SetSessionStateBehavior(SessionStateBehavior sessionStateBehavior) {
            if (_notificationContext != null && _notificationContext.CurrentNotification >= RequestNotification.AcquireRequestState) {
                throw new InvalidOperationException(SR.GetString(SR.Invoke_before_pipeline_event, "HttpContext.SetSessionStateBehavior", "HttpApplication.AcquireRequestState"));
            }
 
            SessionStateBehavior = sessionStateBehavior;
        }

其实很简单，就是设置了一个属性，这里还有一个ReadOnlySessionState属性很重要，他需要读取SessionStateBehavior属性。由于MvcHandler 默认继承了IRequiresSessionState接口但是没有继承IReadOnlySessionState，

所以默认RequiresSessionState为true，ReadOnlySessionState为false。

public IHttpHandler Handler {
            get { return _handler;}
            set {
                _handler = value;
                _requiresSessionStateFromHandler = false;
                _readOnlySessionStateFromHandler = false;
                InAspCompatMode = false;
                if (_handler != null) {
                    if (_handler is IRequiresSessionState) {
                        _requiresSessionStateFromHandler = true;
                    }
                    if (_handler is IReadOnlySessionState) {
                        _readOnlySessionStateFromHandler = true;
                    }
                    Page page = _handler as Page;
                    if (page != null && page.IsInAspCompatMode) {
                        InAspCompatMode = true;
                    }
                }
            }
        }
 
// session state support
        private bool _requiresSessionStateFromHandler;
        internal bool RequiresSessionState {
            get {
                switch (SessionStateBehavior) {
                    case SessionStateBehavior.Required:
                    case SessionStateBehavior.ReadOnly:
                        return true;
                    case SessionStateBehavior.Disabled:
                        return false;
                    case SessionStateBehavior.Default:
                    default:
                        return _requiresSessionStateFromHandler;
                }
            }
        }
 
        private bool _readOnlySessionStateFromHandler;
        internal bool ReadOnlySessionState {
            get {
                switch (SessionStateBehavior) {
                    case SessionStateBehavior.ReadOnly:
                        return true;
                    case SessionStateBehavior.Required:
                    case SessionStateBehavior.Disabled:
                        return false;
                    case SessionStateBehavior.Default:
                    default:
                        return _readOnlySessionStateFromHandler;
                }
            }
        }        

在SessionStateModule的GetSessionStateItem方法里面有如下code：

这里我们用的是RedisSessionStateProvider，其code如下：

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
 
using System;
using System.Web;
using System.Web.SessionState;
 
namespace Microsoft.Web.Redis
{
    public class RedisSessionStateProvider : SessionStateStoreProviderBase
    {
        // We want to release lock (if exists) during EndRequest, to do that we need session-id and lockId but EndRequest do not have these parameter passed to it.
        // So we are going to store 'sessionId' and 'lockId' when we acquire lock. so that EndRequest can release lock at the end.
        // If we removed the lock before that than we will clear these by our self so that EndRequest won't do that again (only Release item exclusive does that).
        internal string sessionId;
        internal object sessionLockId;
        private const int FROM_MIN_TO_SEC = ;
 
        internal static ProviderConfiguration configuration;
        internal static object configurationCreationLock = new object();
        internal ICacheConnection cache;
 
        private static object _lastException = new object();
 
        /// <summary>
        /// We do not want to throw exception from session state provider because this will break customer application and they can't get chance to handel it.
        /// So if exception occurs because of some problem we store it in HttpContext using a key that we know and return null to customer. Now, when customer
        /// get null from any of session operation they should call this method to identify if there was any exception and because of that got null.
        /// </summary>
        public static Exception LastException
        {
            get
            {
                if (HttpContext.Current != null)
                {
                    return (Exception) HttpContext.Current.Items[_lastException];
                }
                return null;
            }
 
            set
            {
                if (HttpContext.Current != null)
                {
                    HttpContext.Current.Items[_lastException] = value;
                }
            }
        }
 
        private void GetAccessToStore(string id)
        {
            if (cache == null)
            {
                cache = new RedisConnectionWrapper(configuration, id);
            }
            else
            {
                cache.Keys.RegenerateKeyStringIfIdModified(id, configuration.ApplicationName);
            }
        }
 
        public override void Initialize(string name, System.Collections.Specialized.NameValueCollection config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }
 
            if (name == null || name.Length == )
            {
                name = "MyCacheStore";
            }
 
            if (String.IsNullOrEmpty(config["description"]))
            {
                config.Remove("description");
                config.Add("description", "Redis as a session data store");
            }
 
            base.Initialize(name, config);
 
            // If configuration exists then use it otherwise read from config file and create one
            if (configuration == null)
            {
                lock (configurationCreationLock)
                {
                    if (configuration == null)
                    {
                        configuration = ProviderConfiguration.ProviderConfigurationForSessionState(config);
                    }
                }
            }
        }
 
        public override bool SetItemExpireCallback(SessionStateItemExpireCallback expireCallback)
        {
            //We don't receive notifications when cache items expire, so we can't support Session_OnEnd.
            return false;
        }
 
        public override void InitializeRequest(HttpContext context)
        {
            //Not need. Initializing in 'Initialize method'.
        }
 
        public override void Dispose()
        {
            //Not needed. Cleanup is done in 'EndRequest'.
        }
 
        public override void EndRequest(HttpContext context)
        {
            try
            {
                // This check is required for unit tests to work
                int sessionTimeoutInSeconds;
                if (context != null && context.Session != null)
                {
                    sessionTimeoutInSeconds = context.Session.Timeout * FROM_MIN_TO_SEC;
                }
                else
                {
                    sessionTimeoutInSeconds = (int)configuration.SessionTimeout.TotalSeconds;
                }
 
                if (sessionId != null && sessionLockId != null)
                {
                    GetAccessToStore(sessionId);
                    cache.TryReleaseLockIfLockIdMatch(sessionLockId, sessionTimeoutInSeconds);
                    LogUtility.LogInfo("EndRequest => Session Id: {0}, Session provider object: {1} => Lock Released with lockId {2}.", sessionId, this.GetHashCode(), sessionLockId);
                    sessionId = null;
                    sessionLockId = null;
                }
                cache = null;
            }
            catch (Exception e)
            {
                LogUtility.LogError("EndRequest => {0}", e.ToString());
                LastException = e;
                if (configuration.ThrowOnError)
                {
                    throw;
                }
            }
        }
 
        public override SessionStateStoreData CreateNewStoreData(HttpContext context, int timeout)
        {
            //Creating empty session store data and return it.
            LogUtility.LogInfo("CreateNewStoreData => Session provider object: {0}.", this.GetHashCode());
            return new SessionStateStoreData(new ChangeTrackingSessionStateItemCollection(), new HttpStaticObjectsCollection(), timeout);
        }
 
        public override void CreateUninitializedItem(HttpContext context, string id, int timeout)
        {
            try
            {
                if (LastException == null)
                {
                    LogUtility.LogInfo("CreateUninitializedItem => Session Id: {0}, Session provider object: {1}.", id, this.GetHashCode());
                    ISessionStateItemCollection sessionData = new ChangeTrackingSessionStateItemCollection();
                    sessionData["SessionStateActions"] = SessionStateActions.InitializeItem;
                    GetAccessToStore(id);
                    // Converting timout from min to sec
                    cache.Set(sessionData, (timeout * FROM_MIN_TO_SEC));
                }
            }
            catch (Exception e)
            {
                LogUtility.LogError("CreateUninitializedItem => {0}", e.ToString());
                LastException = e;
                if (configuration.ThrowOnError)
                {
                    throw;
                }
            }
        }
 
        public override SessionStateStoreData GetItem(HttpContext context, string id, out bool locked, out TimeSpan lockAge, out object lockId, out SessionStateActions actions)
        {
            LogUtility.LogInfo("GetItem => Session Id: {0}, Session provider object: {1}.", id, this.GetHashCode());
            return GetItemFromSessionStore(false, context, id, out locked, out lockAge, out lockId, out actions);
        }
 
        public override SessionStateStoreData GetItemExclusive(HttpContext context, string id, out bool locked, out TimeSpan lockAge, out object lockId, out SessionStateActions actions)
        {
            LogUtility.LogInfo("GetItemExclusive => Session Id: {0}, Session provider object: {1}.", id, this.GetHashCode());
            return GetItemFromSessionStore(true, context, id, out locked, out lockAge, out lockId, out actions);
        }
 
        private SessionStateStoreData GetItemFromSessionStore(bool isWriteLockRequired, HttpContext context, string id, out bool locked, out TimeSpan lockAge, out object lockId, out SessionStateActions actions)
        {
            try
            {
                SessionStateStoreData sessionStateStoreData = null;
                locked = false;
                lockAge = TimeSpan.Zero;
                lockId = ;
                actions = SessionStateActions.None;
                if (id == null)
                {
                    return null;
                }
                GetAccessToStore(id);
                ISessionStateItemCollection sessionData = null;
 
                int sessionTimeout;
                bool isLockTaken = false;
                //Take read or write lock and if locking successful than get data in sessionData and also update session timeout
                if (isWriteLockRequired)
                {
                    isLockTaken = cache.TryTakeWriteLockAndGetData(DateTime.Now, (int)configuration.RequestTimeout.TotalSeconds, out lockId, out sessionData, out sessionTimeout);
                    sessionId = id; // signal that we have to remove lock in EndRequest
                    sessionLockId = lockId; // save lockId for EndRequest
                }
                else
                {
                    isLockTaken = cache.TryCheckWriteLockAndGetData(out lockId, out sessionData, out sessionTimeout);
                }
 
                if (isLockTaken)
                {
                    locked = false;
                    LogUtility.LogInfo("GetItemFromSessionStore => Session Id: {0}, Session provider object: {1} => Lock taken with lockId: {2}", id, this.GetHashCode(), lockId);
                }
                else
                {
                    sessionId = null;
                    sessionLockId = null;
                    locked = true;
                    LogUtility.LogInfo("GetItemFromSessionStore => Session Id: {0}, Session provider object: {1} => Can not lock, Someone else has lock and lockId is {2}", id, this.GetHashCode(), lockId);
                }
 
                // If locking is not successful then do not return any result just return lockAge, locked=true and lockId.
                // ASP.NET tries to acquire lock again in 0.5 sec by calling this method again. Using lockAge it finds if
                // lock has been taken more than http request timeout than ASP.NET calls ReleaseItemExclusive and calls this method again to get lock.
                if (locked)
                {
                    lockAge = cache.GetLockAge(lockId);
                    return null;
                }
 
                if (sessionData == null)
                {
                    // If session data do not exists means it might be exipred and removed. So return null so that asp.net can call CreateUninitializedItem and start again.
                    // But we just locked the record so first release it
                    ReleaseItemExclusive(context, id, lockId);
                    return null;
                }
 
                // Restore action flag from session data
                if (sessionData["SessionStateActions"] != null)
                {
                    actions = (SessionStateActions)Enum.Parse(typeof(SessionStateActions), sessionData["SessionStateActions"].ToString());
                }
 
                //Get data related to this session from sessionDataDictionary and populate session items
                sessionData.Dirty = false;
                sessionStateStoreData = new SessionStateStoreData(sessionData, new HttpStaticObjectsCollection(), sessionTimeout);
                return sessionStateStoreData;
            }
            catch (Exception e)
            {
                LogUtility.LogError("GetItemFromSessionStore => {0}", e.ToString());
                locked = false;
                lockId = null;
                lockAge = TimeSpan.Zero;
                actions = ;
                LastException = e;
                if (configuration.ThrowOnError)
                {
                    throw;
                }
                return null;
            }
        }
 
        public override void ResetItemTimeout(HttpContext context, string id)
        {
            try
            {
                if (LastException == null)
                {
                    LogUtility.LogInfo("ResetItemTimeout => Session Id: {0}, Session provider object: {1}.", id, this.GetHashCode());
                    GetAccessToStore(id);
                    cache.UpdateExpiryTime((int)configuration.SessionTimeout.TotalSeconds);
                    cache = null;
                }
            }
            catch (Exception e)
            {
                LogUtility.LogError("ResetItemTimeout => {0}", e.ToString());
                LastException = e;
                if (configuration.ThrowOnError)
                {
                    throw;
                }
            }
        }
 
        public override void RemoveItem(HttpContext context, string id, object lockId, SessionStateStoreData item)
        {
            try
            {
                if (LastException == null && lockId != null)
                {
                    LogUtility.LogInfo("RemoveItem => Session Id: {0}, Session provider object: {1}.", id, this.GetHashCode());
                    GetAccessToStore(id);
                    cache.TryRemoveAndReleaseLockIfLockIdMatch(lockId);
                }
            }
            catch (Exception e)
            {
                LogUtility.LogError("RemoveItem => {0}", e.ToString());
                LastException = e;
                if (configuration.ThrowOnError)
                {
                    throw;
                }
            }
        }
 
        public override void ReleaseItemExclusive(HttpContext context, string id, object lockId)
        {
            try
            {
                // This check is required for unit tests to work
                int sessionTimeoutInSeconds;
                if (context != null && context.Session != null)
                {
                    sessionTimeoutInSeconds = context.Session.Timeout * FROM_MIN_TO_SEC;
                }
                else
                {
                    sessionTimeoutInSeconds = (int)configuration.SessionTimeout.TotalSeconds;
                }
 
                if (LastException == null && lockId != null)
                {
                    LogUtility.LogInfo("ReleaseItemExclusive => Session Id: {0}, Session provider object: {1} => For lockId: {2}.", id, this.GetHashCode(), lockId);
                    GetAccessToStore(id);
                    cache.TryReleaseLockIfLockIdMatch(lockId, sessionTimeoutInSeconds);
                    // Either already released lock successfully inside above if block
                    // Or we do not hold lock so we should not release it.
                    sessionId = null;
                    sessionLockId = null;
                }
            }
            catch (Exception e)
            {
                LogUtility.LogError("ReleaseItemExclusive => {0}", e.ToString());
                LastException = e;
                if (configuration.ThrowOnError)
                {
                    throw;
                }
            }
        }
 
        public override void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem)
        {
            try
            {
                if (LastException == null)
                {
                    GetAccessToStore(id);
                    // If it is new record
                    if (newItem)
                    {
                        ISessionStateItemCollection sessionItems = null;
                        if (item != null && item.Items != null)
                        {
                            sessionItems = item.Items;
                        }
                        else
                        {
                            sessionItems = new ChangeTrackingSessionStateItemCollection();
                        }
 
                        if (sessionItems["SessionStateActions"] != null)
                        {
                            sessionItems.Remove("SessionStateActions");
                        }
 
                        // Converting timout from min to sec
                        cache.Set(sessionItems, (item.Timeout * FROM_MIN_TO_SEC));
                        LogUtility.LogInfo("SetAndReleaseItemExclusive => Session Id: {0}, Session provider object: {1} => created new item in session.", id, this.GetHashCode());
                    } // If update if lock matches
                    else
                    {
                        if (item != null && item.Items != null)
                        {
                            if (item.Items["SessionStateActions"] != null)
                            {
                                item.Items.Remove("SessionStateActions");
                            }
                            // Converting timout from min to sec
                            cache.TryUpdateAndReleaseLockIfLockIdMatch(lockId, item.Items, (item.Timeout * FROM_MIN_TO_SEC));
                            LogUtility.LogInfo("SetAndReleaseItemExclusive => Session Id: {0}, Session provider object: {1} => updated item in session.", id, this.GetHashCode());
                        }
                    }
                }
            }
            catch (Exception e)
            {
                LogUtility.LogError("SetAndReleaseItemExclusive => {0}", e.ToString());
                LastException = e;
                if (configuration.ThrowOnError)
                {
                    throw;
                }
            }
        }
    }
}

其中GetItem和GetItemExclusive都是调用GetItemFromSessionStore方法，如果入口是GetItem调用TryCheckWriteLockAndGetData方法（不会发生锁），入口时GetItemExclusive调用TryTakeWriteLockAndGetData方法（会有锁），但是这2个方法都会修改Session的SessionTimeout值。

TryTakeWriteLockAndGetData方法的实现如下：

运行结果如下：

TryCheckWriteLockAndGetData的实现如下：

在GetItemFromSessionStore方法中如果获取ISessionStateItemCollection实例为null，我们调用 ReleaseItemExclusive(context, id, lockId)方法来释放锁（前提是前面调用TryTakeWriteLockAndGetData已经获取lockId），一般这个方法都不会执行的，现在我们知道默认情况下载装在session的时候就会锁，如果session实例为null我们会释放我们的锁。

那么这个锁又是是么时候释放的了？在 app.ReleaseRequestState += new EventHandler(this.OnReleaseState);会调用我们这里的SetAndReleaseItemExclusive方法，默认情况下它会释放我们的锁。

运行该方法结果如下：

其实现code如下：

RedisSessionStateProvider为了保证性能，在EndRequest里面还会尝试 释放锁。

到现在我们知道默认加载Session数据的时候会加锁，在ReleaseRequestState事件默认解锁。