相关疑难解决方法(0)

我正在使用ConcurrentQueue共享数据结构,其目的是保存传递给它的最后N个对象(历史记录类型).

假设我们有一个浏览器,我们希望最后100个浏览Urls.我想要一个队列,当容量变满时(历史中的100个地址),当新条目插入(入队)时自动删除(出列)最旧的(第一个)条目.

我怎样才能实现这个目标System.Collections？

我知道在某些情况下,例如长时间运行的进程,锁定ASP.NET缓存非常重要,以避免其他用户对该资源的后续请求再次执行长进程而不是命中缓存.

在ASP.NET中实现缓存锁定的最佳方法是什么？

我正在设计一个类,我希望在主线程完成配置之后只读它,即"冻结"它.Eric Lippert将这种冰棍称为不变性.冻结后,可以同时访问多个线程进行读取.

我的问题是如何以线程安全的方式编写这个实际有效的方法,即不要试图不必要地聪明.

尝试1:

public class Foobar
{
   private Boolean _isFrozen;

   public void Freeze() { _isFrozen = true; }

   // Only intended to be called by main thread, so checks if class is frozen. If it is the operation is invalid.
   public void WriteValue(Object val)
   {
      if (_isFrozen)
         throw new InvalidOperationException();

      // write ...
   }

   public Object ReadSomething()
   {
      return it;
   }
}

Eric Lippert似乎认为这篇文章可以.我知道写入具有释放语义,但据我所知,这仅适用于排序,并不一定意味着所有线程都会在写入后立即看到该值.谁能证实这一点？这意味着这个解决方案不是线程安全的(当然这可能不是唯一的原因).

尝试2:

以上,但Interlocked.Exchange用于确保实际发布的值:

public …

MSDN 在C#中给出了关于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.

Run Code Online (Sandbox Code Playgroud)

然而,它没有为它提供任何可靠的推理.锁(这个)在这里解释了SO.我对lock(typeof(MyType))案件感兴趣.有什么危险吗？

谢谢.

在阅读了文章"Simmering Unicode,让DPL沸腾"和"Simmering Unicode,让DPL沸腾(第2部分)"的"Oracle Delphi"(Allen Bauer)之后,Oracle就是我理解的全部:)

文章提到了Delphi Parallel Library(DPL),锁定免费数据结构,互斥锁和条件变量(这篇维基百科文章转发到' Monitor(同步) ',然后介绍了用于线程同步的新TMonitor记录类型并描述了它的一些方法.

是否有介绍文章,其中的示例显示了何时以及如何使用此Delphi记录类型？网上有一些文档.

• TCriticalSection和TMonitor之间的主要区别是什么？

• 我能做些什么与Pulse和PulseAll方法呢？

• 它是否具有例如C#或Java语言的对应物？

• RTL或VCL中是否有使用此类型的代码(因此它可以作为示例)？

更新:文章为什么在Delphi 2009中TObject的大小翻了一番？解释说现在可以使用TMonitor记录锁定Delphi中的每个对象,每个实例需要额外四个字节.

看起来TMonitor的实现类似于Java语言中的Intrinsic Locks:

每个对象都有一个与之关联的内在锁.按照惯例,需要对对象字段进行独占和一致访问的线程必须在访问对象之前获取对象的内部锁,然后在完成它们时释放内部锁.

等待,Delphi中的Pulse和PulseAll似乎是Java编程语言中wait(),notify()和notifyAll()的对应物.如果我错了,请纠正我:)

更新2:生产者/消费者应用程序的示例代码,使用TMonitor.Wait和TMonitor.PulseAll基于Java(tm)教程中有关保护方法的文章(欢迎评论):

这种应用程序在两个线程之间共享数据:生成器,创建数据,以及使用它的消费者.两个线程使用共享对象进行通信.协调是必不可少的:消费者线程不得在生产者线程交付之前尝试检索数据,并且如果消费者未检索旧数据,则生产者线程不得尝试传递新数据.

在此示例中,数据是一系列文本消息,通过Drop类型的对象共享:

program TMonitorTest;

// based on example code at http://download.oracle.com/javase/tutorial/essential/concurrency/guardmeth.html

{$APPTYPE CONSOLE}

uses
  SysUtils, Classes;

type
  Drop = …

使用多个线程时,共享内存需要被关键部分锁定.但是,使用关键部分会导致潜在的死锁.他们怎么能避免？

我在C#中有一个函数,可以从多个线程多次调用,我希望它只能完成一次,所以我想到了这个:

class MyClass
{
    bool done = false;
    public void DoSomething()
    {
        lock(this)
            if(!done)
            {
                done = true;
                _DoSomething();
            }
    }
}

问题是_DoSomething需要很长时间,我不希望很多线程等待它,只要他们可以看到这done是真的.
这样的事情可以解决方法:

class MyClass
{
    bool done = false;
    public void DoSomething()
    {
        bool doIt = false;
        lock(this)
            if(!done)
                doIt = done = true;
        if(doIt)
             _DoSomething();
    }
}

但只需手动锁定和解锁就会好得多.
我怎样才能手动锁定和解锁lock(object)？我需要它使用相同的接口,lock因此这种手动方式lock将相互阻塞(对于更复杂的情况).

锁定类的类型与类本身的锁定有什么区别？

例如:

private readonly object xmpp = new object();

lock (xmpp)
{
    ...
}

VS

lock (typeof(Xmpp))
{
    ...
}

我创建了一个Windows服务,它应该每隔60秒检查数据库中的某个表以获取新行.对于添加的每个新行,我需要在服务器上进行一些繁重的处理,有时可能需要超过60秒.

我在我的服务中创建了一个Timer对象,每隔60秒就会调用一次,并调用所需的方法.
由于我不想在处理找到的新行时勾选此计时器lock { },因此我将该方法包装在一个块中,因此其他线程无法访问此方法.

它看起来像这样:

Timer serviceTimer = new Timer();
serviceTimer.Interval = 60;
serviceTimer.Elapsed += new ElapsedEventHandler(serviceTimer_Elapsed);
serviceTimer.Start();

void serviceTimer_Elapsed(object sender, ElapsedEventArgs e)
{
    lock (this)
    {
        // do some heavy processing...
    }
}

现在,我想知道 -
如果我的计时器滴答,并在数据库上发现了很多新行,现在处理将花费超过60秒,下一个滴答将不会进行任何处理,直到前一个完成.这就是我想要的效果.

但现在,serviceTimer_Elapsed方法会在第一次处理完成后立即关闭,还是会等待计时器再次打勾.

我想要发生的是 - 如果处理需要超过60秒,那么计时器会注意到线程被锁定,再等待60秒再次检查,这样我就永远不会陷入有线程队列的情况等待前一个完成.

我怎样才能完成这个结果？
这样做的最佳做法是什么？

谢谢!

我想@synchronized块不依赖于对象,但依赖于线程......对吗？在那种情况下,为什么我们通过自我？