标签: locking

假设一个类有一个public int counter由多个线程访问的字段.这int只是递增或递减.

要增加此字段,应使用哪种方法,为什么？

• lock(this.locker) this.counter++;,
• Interlocked.Increment(ref this.counter);,
• 将访问修饰符更改counter为public volatile.

现在,我发现volatile,我已经删除了许多lock语句和使用Interlocked.但是有理由不这样做吗？

我理解乐观和悲观锁定*之间的区别.现在有人可以向我解释我何时会使用其中任何一个？

这个问题的答案是否会根据我是否使用存储过程来执行查询而改变？

*但只是为了检查,乐观的意思是"在阅读时不要锁定桌子",悲观意味着"在阅读时锁定桌面".

我看到,对于使用非线程安全的对象,我们用这样的锁包装代码:

private static readonly Object obj = new Object();

lock (obj)
{
    // thread unsafe code
}

那么当多个线程访问相同的代码时会发生什么(让我们假设它在ASP.NET Web应用程序中运行).他们排队了吗？如果是这样,他们会等多久？

使用锁会对性能产生什么影响？

在MSDN文档说,

public class SomeObject
{
  public void SomeOperation()
  {
    lock(this)
    {
      //Access instance variables
    }
  }
}

如果可以公开访问实例,那就是"一个问题".我想知道为什么？是因为锁定的持有时间超过了必要的时间吗？还是有一些更阴险的原因？

任何人都可以通过一个例子告诉我同步方法优于synchronized块的优势吗？

我听说过这些与并发编程有关的词,但它们之间的区别是什么？

看到各种锁定相关的问题和(几乎)总是找到'循环因为虚假的唤醒'术语¹我想知道,有没有人经历过这样的唤醒(假设一个像样的硬件/软件环境)？

我知道"虚假"一词意味着没有明显的理由,但这种事件的原因是什么？

(¹注意:我不是在质疑循环练习.)

编辑:一个帮助问题(对于那些喜欢代码示例的人):

如果我有以下程序,我运行它:

public class Spurious {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition cond = lock.newCondition();
        lock.lock();
        try {
            try {
                cond.await();
                System.out.println("Spurious wakeup!");
            } catch (InterruptedException ex) {
                System.out.println("Just a regular interrupt.");
            }
        } finally {
            lock.unlock();
        }
    }
}

await如果不等待随机事件,我该怎么做才能虚假地唤醒它？

我想真正的问题是:

如果我不关心脏读,将添加with(NOLOCK)提示到SELECT语句会影响性能:

1. 当前的SELECT语句
2. 针对给定表的其他事务

例:

Select * 
from aTable with (NOLOCK)

POSIX允许互斥锁递归.这意味着同一个线程可以锁定相同的互斥锁两次并且不会死锁.当然它还需要解锁两次,否则没有其他线程可以获得互斥锁.并非所有支持pthread的系统都支持递归互斥锁,但如果它们想要符合POSIX,则必须使用.

其他API(更高级别的API)通常也提供互斥锁,通常称为锁定.一些系统/语言(例如Cocoa Objective-C)提供递归和非递归互斥体.有些语言也只提供一种或另一种语言.例如,在Java中,互斥锁总是递归的(同一个线程可能在同一个对象上"同步"两次).根据它们提供的其他线程功能,没有递归互斥体可能没有问题,因为它们可以很容易地自己编写(我已经在更简单的互斥/条件操作的基础上自己实现了递归互斥锁).

我真的不明白:什么是非递归互斥量有用？如果它锁定相同的互斥锁两次,为什么我想要一个线程死锁？即使是可以避免这种情况的高级语言(例如测试它是否会死锁并抛出异常)通常也不会这样做.他们会让线程陷入僵局.

这只适用于我意外锁定它两次并且只解锁一次的情况,并且在递归互斥锁的情况下,它会更难找到问题,所以相反我立即死锁以查看错误锁定出现在哪里？但是我不能在解锁时返回一个锁定计数器并且在某种情况下,我确定我释放了最后一个锁并且计数器不为零,我可以抛出异常或记录问题吗？或者是否有其他更有用的非递归互斥体用例我看不到？或者它可能只是性能,因为非递归互斥体可能比递归互斥体略快？但是,我对此进行了测试,差异确实不大.

如果我在同一个类中有2个同步方法,但每个方法访问不同的变量,那么2个线程可以同时访问这两个方法吗？锁是否发生在对象上,或者它是否与synchronized方法中的变量一样具体？

例:

class X {

    private int a;
    private int b;

    public synchronized void addA(){
        a++;
    }

    public synchronized void addB(){
        b++;
    }

}

2个线程可以同时访问同一个X类实例x.addA()x.addB()吗？