Tag: 文件locking

Java线程转储：“等待locking”和“停车等待”之间的区别？

在Java线程转储中，您可以看到堆栈跟踪中提到的锁。 似乎有三种信息： 1： – locked <0x00002aab329f7fa0> (a java.io.BufferedInputStream) 2： – waiting to lock <0x00002aaaf4ff6fa0> (a org.alfresco.repo.lock.LockServiceImpl) 3： – parking to wait for <0x00002aaafbf70bb8> (a java.util.concurrent.SynchronousQueue$TransferStack) 1：线程已获得对象0x00002aab329f7fa0的locking。 2＆3：似乎说线程正在等待所述对象的locking变为可用… 但是2和3有什么区别？

你将如何在C ++ 11中实现自己的读写器locking？

我有一套数据结构，需要使用读写器锁保护。 我知道boost :: shared_lock，但我想有一个使用std :: mutex，std :: condition_variable和/或std :: atomic的自定义实现，以便我可以更好地理解它是如何工作的（并稍后调整它） 。 每个数据结构（可移动，但不可复制）将从一个称为Commons的类inheritance，该类封装了locking。 我想公共界面看起来像这样： class Commons { public: void read_lock(); bool try_read_lock(); void read_unlock(); void write_lock(); bool try_write_lock(); void write_unlock(); }; …所以它可以被一些公开的inheritance： class DataStructure : public Commons {}; 我正在写科学的代码，通常可以避免数据竞赛; 这个锁主要是防止我以后可能会犯的错误。 因此我的优先级是低的读取开销，所以我不会妨碍正确运行的程序太多。 每个线程都可能运行在自己的CPU内核上。 你能告诉我（伪代码是好的）读者/写作者锁？ 我现在所拥有的应该是防止作家饥饿的变种。 到目前为止，我的主要问题是read_lock在检查read是否安全以实际递增读取器计数之间的差距，之后write_lock知道要等待。 void Commons::write_lock() { write_mutex.lock(); reading_mode.store(false); while(readers.load() > 0) {} } void […]

行被其他事务更新或删除（或未保存的值映射不正确）

我有一个在Web服务器上运行的Java项目。 我总是打这个例外。 我读了一些文档，发现悲观的locking（或乐观的，但我读的悲观是更好的）是防止这种exception的最好办法。 但是我找不到任何可以解释如何使用它的明确例子。 我的方法是： @Transactional Public void test(Email email, String Subject){ getEmailById(String id); email.setSubject(Subject); updateEmail(email); } 而： Email是一个hibernate类（它将是数据库中的一个表） getEmailById(String id)是一个函数，返回一个email （这个方法不是@Transctional注释） updateEmail(email) ：是一个更新电子邮件的方法。 注：我使用hibernate保存，更新等（例如： session.getcurrentSession.save(email) ） 例外： ERROR 2011-12-21 15:29:24,910 Could not synchronize database state with session [myScheduler-1] org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect): [email#21] at […]

为什么“lock（typeof（MyType））”有问题？

MSDN给出了关于C＃中的锁关键字的以下警告： 通常，避免locking公共types或超出代码控制范围的实例。 常见的构造函数lock（this），lock（typeof（MyType））和lock（“myLock”）违反了这个指导原则： * lock (this) is a problem if the instance can be accessed publicly. * lock (typeof (MyType)) is a problem if MyType is publicly accessible. 然而，它没有给出可靠的推理。 锁（这） 在这里解释。 我感兴趣的是lock（typeof（MyType））的情况。 什么危险呢？ 谢谢。

如何find什么是locking我的表

我有一个SQL表，突然之间不能返回数据，除非我在结尾包含“（nolock）”，这表明某种锁在我的表上。 我已经用dm_tran_locks做了一些尝试，以确定表中有多less个锁，但是如何识别locking它们的内容（即dm_tran_locks的请求元素）？ 编辑：我知道关于pre SQL 2005 sp_lock，但现在，该sp已被弃用，AFAIK正确的方式来做到这一点与dm_tran_locks。 我正在使用SQL Server 2008 R2。

了解多重处理：Python中的共享内存pipe理，locking和队列

多进程是Python中的一个强大的工具，我想更深入地理解它。 我想知道什么时候使用常规的 锁和队列以及何时使用多处理器pipe理器在所有进程之间共享这些。 我想出了四种不同的多处理条件下的testing场景： 使用池和NOpipe理器 使用一个池和一个经理 使用单个进程和NOpipe理器 使用单独的进程和pipe理器 工作 所有的条件执行工作职能the_job 。 the_job包含一些由锁保护的打印。 而且，函数的input只是简单地放入一个队列（查看是否可以从队列中恢复）。 这个input只是在主脚本start_scenario创build的range(10)的索引idx （显示在底部）。 def the_job(args): """The job for multiprocessing. Prints some stuff secured by a lock and finally puts the input into a queue. """ idx = args[0] lock = args[1] queue=args[2] lock.acquire() print 'I' print 'was ' print 'here ' print '!!!!' […]

为什么在同步块中使用volatile？

我在java中看到了一些例子，他们在代码块上进行同步以更改某个variables，而该variables最初被声明为volatile。我看到，在一个单例类的例子中，他们声明了唯一实例是volatile，并且它们同步了块初始化该实例…我的问题是为什么我们声明它是同步的，为什么我们需要做这两个？ 是不是其中之一是足够的？ public class someClass { volatile static uniqueInstance = null; public static someClass getInstance() { if(uniqueInstance == null) { synchronized(someClass.class) { if(uniqueInstance == null) { uniqueInstance = new someClass(); } } } return uniqueInstance; } 提前致谢。

可以使用string作为锁对象吗？

我需要在一个有限的string的基础上在一个地区做一个关键的部分。 我想要锁被共享相同的string实例，（有点类似于String.Intern方法）。 我正在考虑以下实施： public class Foo { private readonly string _s; private static readonly HashSet<string> _locks = new HashSet<string>(); public Foo(string s) { _s = s; _locks.Add(s); } public void LockMethod() { lock(_locks.Single(l => l == _s)) { … } } } 这种方法有什么问题吗？ 以这种方式lockingstring对象是否可行，并且在使用HashSet<string>是否存在线程安全问题？ 例如，创build一个为每个string实例创build一个新的locking对象的Dictionary<string, object>会更好吗？ 最终实施 根据我的build议，进行了以下的实施： public class Foo { private readonly string […]

在multithreading场景中调用Dictionary对象的set_item方法时抛出NullReferenceException

我们的网站有一个configuration页面，如“config.aspx”，当页面初始化时会从configuration文件中加载一些信息。 为了caching加载的信息，我们提供了一个工厂类，我们调用工厂的一个公共方法来获取页面加载时的configuration实例。 但有时候，当应用程序池重新启动时，我们在事件日志中发现了一些错误信息，例如： 消息：对象引用未设置为对象的实例。 堆栈：在System.Collections.Generic.Dictionary`2.Insert（TKey键，TValue值，布尔添加） 在System.Collections.Generic.Dictionary`2.set_Item（TKey键，TValue值） 在ObjectFactory.GetInstance（string键） 在config.Page_Load（对象发件人，EventArgs e） 在System.Web.Util.CalliHelper.EventArgFunctionCaller（IntPtr fp，Object o，Object t，EventArgs e） 在System.Web.Util.CalliEventHandlerDelegateProxy.Callback（对象发件人，EventArgs e） 在System.Web.UI.Control.OnLoad（EventArgs e） 在System.Web.UI.Control.LoadRecursive（） 在System.Web.UI.Page.ProcessRequestMain（布尔includeStagesBeforeAsyncPoint，布尔includeStagesAfterAsyncPoint） 工厂类实现如下： public static class ObjectFactory { private static object _InternalSyncObject; private static Dictionary _Instances; private static object InternalSyncObject { get { if (_InternalSyncObject == null) { var @object = new object(); Interlocked.CompareExchange(ref _InternalSyncObject, @object, null); […]

std :: lock_guard或std :: scoped_lock？

C ++ 17引入了一个名为std::scoped_lock的新的锁类。 从文档看，它看起来类似于已经存在的std::lock_guard类。 有什么区别，我应该什么时候使用它？