标签: locks

我的目标是:

有一定范围的整数,我必须测试该范围内的每个整数是否随机.我想为此使用多个线程,并使用共享计数器在线程之间平均分配工作.我将计数器设置为开始值,让每个线程取一个数字,增加它,进行一些计算,然后返回一个结果.此共享计数器必须使用锁增加,否则将在要测试的整数范围内存在间隙/重叠.

我不知道从哪里开始.假设我想要12个线程来完成工作,我这样做:

for (int t = 0; t < threads; t++)
{
  Thread thr = new Thread(new ThreadStart(startThread));
}

startThread() 是我用于计算的方法.

你能帮帮我吗？我知道我必须使用Interlocked类,但这就是......

我有一个事件处理程序，只要在串行端口上接收到数据，它就会被调用，一旦调用此事件，我就会处理单个字节的数据，直到处理完所有数据。

我的问题是，如何确保这个 IBSerialPort_DataReceived 事件处理程序在我第一次被调用时仍在处理字节时不会再次被异步调用，即我想保证 ProcessByte 方法只在一个线程上执行一次。

void IBSerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
  while (BytesToRead > 0)
  {
    ProcessByte((byte)ReadByte());
  }
}

这是我面临的问题.在运行下面的代码时,我有时会在打印B的内容时收到过时的数据.我无法理解为什么会发生这种情况,因为更新和接收B的内容受B锁的保护.

请注意,在更新到B期间,A和B的锁都被保留.访问B的内容时,只保留一个锁.

另请注意,B.updated()未同步,但我不认为这是问题,因为我确保更新的计数器设置为2,然后才访问B的内容.

class B {
  Object data
  int updated = 0

  // get and set protected by B's monitor
  synchronized Object getData() {
    return data;
  }
  synchronized setData(Object d) {
    data = d;
    updated += 1;
  }
  // deliberately not synchronized
  int updated() { return updated; }
}

class A {
    B b
    A() {
        new Thread t = new Thread(new UpdaterThread());
        t.start();
    }

   // when B is updated both A and B monitors are held
    synchronized String setB(Object …

我有这个错误:错误c2064:term不评估为采用0参数的函数.事情是函数接受0参数,我调用0参数,我不明白什么是错的.

    RWLock* rwl = new RWLock();
    std::thread t1(&RWLock::read);

这是对函数的调用.这是功能:

    void read();

有人知道问题是什么吗？提前致谢!

Linux内核中页表的PMD和PTE级别有两个锁。每次线程/进程分配/映射内存时，它都应该持有这些锁之一以相应地更新页表。显然，随着线程数量的增加，持有锁的竞争也会增加。这可能会降低内存映射吞吐量，因为许多线程持有自旋锁。

我想要测量的任务是这些锁对内存映射吞吐量的最坏情况开销，但我不知道如何测量它。

我尝试在增加运行同一循环的线程数时使用mallocin an 。infinite-loop我检查/proc/{pid}/maps每组正在运行的线程以计算映射内存的数量。但我不确定这是否是正确的方法。此外，这种方法会消耗大量内存。

有没有有效的方法来衡量这些锁的最坏情况开销？

假设我有一个并且想要做类似下面的事情,除了我只想锁定我正在处理的特定字典条目而不是整个字典:static Dictionary<string, object>

lock(myDictionary)
{
   if(myDictionary["myKey"] == null)
   {
      myDictionary["myKey"] = new MyClass();
   }
}

如果不编写我自己的Dictionary实现,这可能吗？

谢谢,

我有这个代码,现在任何人都可以回答在以下情况下锁会发生什么,考虑到cond是真的: -

for (;;) {
static mutex m;
Lock lock(m);
if (cond)
break;
... 
} 

谢谢

我有一个由作家和读者组成的程序，其访问权限由监视器控制。

因此，这本来很饿，但我陷入了僵局。我想知道为什么，然后我想起我又放了一把锁，我认为这对于在读取器内部的读取方法内部是不必要的，以防止全局变量受到不一致的影响。我认为这不会造成任何死锁，因为我可以在没有任何死锁的情况下运行10000次线程，但是当我必须进行实验室演示时，它在我认为的第10010个线程处死锁。我不明白为什么会那样做。另外，我没想到它会饿死，但显然它应该这样做。

我的问题是：这些多级锁是否导致死锁？如果没有，这是什么原因造成的？

    import java.io.*;
    import java.io.IOException;
    import java.util.*;

    public class Writer extends Thread{

    private int number;

    public Writer(int number)
    {
        this.number = number;
    }

    public int getNumber()
    {
        return number;
    }

        public static void Write(String filename){

        try {

            String content = RandomString();


            File f = new File(filename);

            if (!f.exists())
            {
                f.createNewFile();
            }


            PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("Task1out.txt", true)));
            out.println(content);
            out.close();


        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static String RandomString(){

        String chars = new String("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"); …

在旧的同步块中，我们使用相同的对象进行同步，还使用了等待和通知方法。所以他们都可以引用同一个锁。说得通。

那么当我使用类 ReentrantLock 时，为什么我不能也使用相同的变量来调用lock、unlock以及await和signal？为什么我需要创建额外的 Condition 变量？

也就是说，为什么我需要这样做：

Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    void doSomething() {
        lock.lock();
            //some code
            condition.await();
            //some code
        lock.unlock();
    }

而不是这样：（这种类型的编码不会更合乎逻辑）？

Lock lock = new ReentrantLock();

    void doSomething() {
        lock.lock();
            //some code
            lock.await();
            //some code
        lock.unlock();
    }

编辑：来自文档：一个 Condition 实例本质上绑定到一个锁。 为什么要这样设计？为什么不只有一个 Lock 类型的变量，它会有 await 和信号方法？