Question

我知道ISession不是线程安全的，SessionFactory是线程安全的。因此，我已经包装并确认每个线程有一个会话。

我在下列情况下收到错误，并且想知道这是不支持的，或者我仍然错过了我的ISession线程隔离的东西。

我正在运行NUnit测试。我有一个场景，我的实体被作为一个字段变量存根。我有一个运行2个并行任务的测试。

•每个并行任务从同一个SessionFactory创建自己的会话，并开始NHibernate事务 •他们每个人都更新实体并对其执行SaveOrUpdate •然后提交并关闭交易每项任务大约做10k次。

在此测试期间，我收到一条消息：

System.AggregateException : One or more errors occurred.
  ----> NHibernate.HibernateException : identifier of an instance of Domain.Entity.MyEntity was altered from 2 to 1

这是有道理的，因为MyEntity是一个字段对象，并被两个线程使用。因此，在NUnit类中创建的单个对象是由两个线程引用和更新的。

我的问题是，悲观锁定或其他NHibernate功能是否可以避免这种情况？或者这是不可行的，我必须确保这种情况（即我的Entity对象一次不被多个线程引用和更新）从未出现在我的代码中？

我已经厌倦了NHibernate中的一些选项，比如确保实体的版本化并尝试了一些锁定调用，但我在黑暗中通过文档猜测这是正确的方法，如果有的话来处理这种情况。

编辑：感谢您的评论！以下是单元测试中的代码：

private PluginConfiguration _configStub1;

    [SetUp]
    public void Setup()
    {
        new FluentMapper().Configuration().ExposeConfiguration(
            e => new SchemaExport(e).Drop(false, true)
            );

        _configStub1 = new PluginConfiguration()
            {
                Enabled = true,
                Keys = "Name",
                Value = "Fred",
                PluginName = "red",
                RuntimeId = 1
            };
     }

    [Test]
    [Explicit]
    public void HighVolume_Saves_MultiManager_SameDataRecord_SameInstance_MultiThread()
    {
        Action action1 = () =>
        {
            var dal = new DataAccessManager();
            for (int i = 0; i < 10000; i++)
            {
                dal.Begin();
                dal.Current.Session.SaveOrUpdate(_configStub1);
                dal.Current.Commit();
                dal.End();
            }
        };

        Action action2 = () =>
        {
            var dal = new DataAccessManager();
            for (int i = 0; i < 10000; i++)
            {
                dal.Begin();
                dal.Current.Session.SaveOrUpdate(_configStub1);
                dal.Current.Commit();
                dal.End();
            }
        };

        var task1 = Task.Factory.StartNew(action1);
        var task2 = Task.Factory.StartNew(action2);

        task1.Wait();
        task2.Wait();
    }

测试中引用的DataAccess Manager如下：

public class DataAccessManager : IDataAccessManager
{
    private readonly ThreadLocal<ISessionManager> _current = new ThreadLocal<ISessionManager>();

    public void Begin()
    {
        Current = new SessionManager();
    }
    public ISessionManager Current
    {
        get { return _current.Value; }
        set { _current.Value = value; }
    }
    public void End(bool doComplete = true)
    {
        bool isActive = Current.Transaction != null && Current.Transaction.IsActive;

        if (doComplete && isActive) Current.Commit();
        else if (!doComplete && isActive) Current.Transaction.Rollback();

        Current.Dispose();
    }
}

SessionManager就是这样：

public class SessionManager : ISessionManager
{
    /// <summary>
    /// Initializes a new instance of the <see cref="SessionManager"/> class.
    /// </summary>
    public SessionManager()
    {
        Session = ContextFactory.OpenSession();
        Transaction = Session.BeginTransaction();
    }

    public ITransaction Transaction { get; private set; }
    public ISession Session { get; private set; }

    public void Commit()
    {
        try
        {
            Transaction.Commit();
        }
        catch (Exception ex)
        {
            Transaction.Rollback();
            throw;
        }
    }
}

Answer 1

正如评论中所述，似乎有两点需要考虑以确保线程安全，以及非冲突的会话：

一旦您的对象被会话处理，就调用Session.Evict（_configStub1）。这样可以防止非垃圾收集的会话与您的对象产生冲突的交互。
在将对象附加到会话之前将其锁定，直到将其从此会话中逐出。这样，您可以确保对象的线程安全。

Answer 2

与会话中当前活动的实体对象（即会话已知）的交互应被视为与会话交互相同。由于会话对于从不同线程并发使用是不安全的，因此也不能访问会话已知的实体对象。

这是因为与实体实例交互可能导致会话延迟加载一些数据，并且在调用Save（）（或类似方法）期间，NHibernate会改变对象以设置id（取决于选择的身份分配）策略）。

以上适用于一般情况。在更狭隘的场景中，有可能安全地完成它，但我认为在引入这种复杂性之前，你应该确定你需要这样的东西。

NHibernate，MultiThreading和共享对象更新冲突

2 个答案: