有一个多线程应用程序，适用于大型数据库文件 (>600 Mb)。当我添加 blob 数据时，“数据库已锁定”问题开始出现，并且每个请求开始使用 >30 Kb 的 BLOB 数据进行操作。我认为问题与小型硬盘速度有关。看起来 SQLite 删除了 -journal 文件，我的应用程序的一个线程失去了锁定(因为 -journal 文件被应用和删除)，而我的其他线程想要对 DB 做 smth，但是 SQLite 仍然更新 DB 文件......当然，我可以在每次数据库调用后延迟一分钟，但这不是解决方案，因为我需要更快的速度。

现在我使用 session 每次 session (每个线程)实现。因此每个应用程序对象有一个 ISessionFactory 和许多 ISession 对象。

有我的帮助类(如您所见，我使用 IsolationLevel.Serializable 和 CurrentSessionContext = ThreadStaticSessionContext):

public abstract class nHibernateHelper
{
    private static FluentConfiguration _configuration;
    private static IPersistenceContext _persistenceContext;

    static nHibernateHelper() {}

    private static FluentConfiguration ConfigurePersistenceLayer()
    {
        return Fluently.Configure().Database(FluentNHibernate.Cfg.Db.SQLiteConfiguration.Standard.ShowSql().UsingFile(_fileName).IsolationLevel(IsolationLevel.Serializable).MaxFetchDepth(2)).
                Mappings(m => m.FluentMappings.AddFromAssemblyOf<Foo>()).CurrentSessionContext(typeof(ThreadStaticSessionContext).FullName);
    }

    public static ISession CurrentSession
    {
        get { return _persistenceContext.CurrentSession; }
    }

    public static IDisposable OpenConnection()
    {
        return new DbSession(_persistenceContext);
    }
}

public class PersistenceContext : IPersistenceContext, IDisposable
{
    private readonly FluentConfiguration _configuration;
    private readonly ISessionFactory _sessionFactory;

    public PersistenceContext(FluentConfiguration configuration)
    {
        _configuration = configuration;
        _sessionFactory = _configuration.BuildSessionFactory();
    }

    public FluentConfiguration Configuration { get { return _configuration; } }
    public ISessionFactory SessionFactory { get { return _sessionFactory; } }

    public ISession CurrentSession
    {
        get
        {
            if (!CurrentSessionContext.HasBind(SessionFactory))
            {
                OnContextualSessionIsNotFound();
            }
            var contextualSession = SessionFactory.GetCurrentSession();
            if (contextualSession == null)
            {
                OnContextualSessionIsNotFound();
            }
            return contextualSession;
        }
    }

    public void Dispose()
    {
        SessionFactory.Dispose();
    }

    private static void OnContextualSessionIsNotFound()
    {
        throw new InvalidOperationException("Ambient instance of contextual session is not found. Open the db session before.");
    }

}

public class DbSession : IDisposable
{
    private readonly ISessionFactory _sessionFactory;

    public DbSession(IPersistenceContext persistentContext)
    {
        _sessionFactory = persistentContext.SessionFactory;
        CurrentSessionContext.Bind(_sessionFactory.OpenSession());
    }

    public void Dispose()
    {
        var session = CurrentSessionContext.Unbind(_sessionFactory);
        if (session != null && session.IsOpen)
        {
            try
            {
                if (session.Transaction != null && session.Transaction.IsActive)
                {
                    session.Transaction.Rollback();
                }
            }
            finally
            {
                session.Dispose();
            }
        }
    }
}

还有存储库助手类。正如您所看到的，每个数据库调用都有锁，因此并发数据库调用不会出现，对于不同的线程也是如此，因为 _locker 对象是静态的。

public abstract class BaseEntityRepository<T, TId> : IBaseEntityRepository<T, TId> where T : BaseEntity<TId>
{
    private ITransaction _transaction;
    protected static readonly object _locker = new object();

    public bool Save(T item)
    {
        bool result = false;

        if ((item != null) && (item.IsTransient()))
        {
            lock (_locker)
            {
                try
                {
                    _transaction = session.BeginTransaction();
                    nHibernateHelper.CurrentSession.Save(item);
                    nHibernateHelper.Flush();
                    _transaction.Commit();          
                    result = true;
                } catch 
                {
                    _transaction.Rollback();
                    throw;
                }
                //DelayAfterProcess();
            }
        }
        return result;
    }

    //same for delete and update 

    public T Get(TId itemId)
    {
        T result = default(T);

        lock (_locker)
        {
            try
            {
                result = nHibernateHelper.CurrentSession.Get<T>(itemId);
            }
            catch 
            {
                throw;
            }
        }
        return result;
    }

    public IList<T> Find(Expression<Func<T, bool>> predicate)
    {
        IList<T> result = new List<T>();
        lock (_locker)
        {
            try
            {
                result = nHibernateHelper.CurrentSession.Query<T>().Where(predicate).ToList();
            }
            catch 
            {
                throw;
            }
        }
        return result;
    }


}

我像这样使用以前的类(我为每个线程调用一次 nHibernateHelper.OpenConnection())。 Repository 由单例实例化:

using (nHibernateHelper.OpenConnection())
{
    Foo foo = new Foo();
    FooRepository.Instance.Save(foo);
}    

我尝试将 IsolationLevel 更改为 ReadCommited，但这并没有改变问题。我还尝试通过将 SQLite 日志模式从日志更改为 WAL 来解决此问题:

using (nHibernateHelper.OpenConnection()) 
{
    using (IDbCommand command = nHibernateHelper.CurrentSession.Connection.CreateCommand())
    {
        command.CommandText = "PRAGMA journal_mode=WAL";
        command.ExecuteNonQuery();
    }
}

这在具有快速 HDD 的计算机上有所帮助，但在某些计算机上我遇到了同样的错误。然后我尝试将“数据库更新文件存在”检查添加到存储库，并在每次保存/更新/删除过程后延迟:

    protected static int _delayAfterInSeconds = 1;
    protected void DelayAfterProcess()
    {
        bool dbUpdateInProcess = false;
        do
        {
            string fileMask = "*-wal*";
            string[] files = Directory.GetFiles(Directory.GetCurrentDirectory(), fileMask);
            if ((files != null) && (files.Length > 0))
            {
                dbUpdateInProcess = true;
                Thread.Sleep(1000);
            }
            else
            {
                dbUpdateInProcess = false;
            }
        } while (dbUpdateInProcess);
        if (_delayAfterInSeconds > 0)
        {
            Thread.Sleep(_delayAfterInSeconds * 1000);
        }
    }

相同的解决方案(检查数据库更新文件)不适用于 -journal 文件。它报告说，-journal 文件已被删除，但我仍然遇到错误。对于 -wal 文件，它可以工作(正如我认为的那样。我需要更多时间来测试它)。但是这个解决方案严重地阻碍了程序。

也许你能帮帮我？

最佳答案

回答我自己。 问题与 .IsolationLevel(IsolationLevel.Serializable) 有关。当我将此行更改为 .IsolationLevel(IsolationLevel.ReadCommitted) 时，问题就消失了。

关于c# - 多线程应用程序中的 SQLite "Database is locked"错误，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/8227796/