C++ 代码中的死锁

Question

我尝试处理我的代码中的死锁，但我不知道如何防止它。我有一个访问数据的线程和一个更新数据的更新方法。代码如下所示：

thread {
    forever {
        if (Running) {
            LOCK
                access data
            UNLOCK
        }
         Running = false;
    }
}

update {
    Running = false;

    LOCK
        access data
    UNLOCK

    Running = true;
}

我尝试使用第二个访问变量来修复它，但它并没有改变任何东西。

thread {
    forever {
        if (!Updating) {
            if (Running) {
                LOCK
                     access data
                UNLOCK
            }
        }
         Running = false;
    }
}

update {
    Updating = true;
    Running = false;

    LOCK
        access data
    UNLOCK

    Updating = false;
    Running = true;
}

感谢您的帮助。

更新 这是对问题的更好描述：

thread {
    forever {
        if (Running) {
            LOCK
                if (!Running) leave
                access data
            UNLOCK
        }
        Running = false;
    }
}

update {
    Running = false;

    LOCK
        access data
    UNLOCK

    Running = true;
}

我的更新函数有点复杂，所以我看不到为此使用标准算法之一的方法。

更新 2 这是简化的 c++ 源代码。也许将其作为伪代码阅读会更好：

void run() {
    forever {
        if (mRunning) {

            QMutexLocker locker(&mMutex);
            for (int i; i < 10; i++) {
                qDebug("run %d", i);
                sleep(1);
                if (!mRunning) break;
            }

            mRunning = false;
        }
    }
}

void update() {
    mRunning = false;

    QMutexLocker locker(&mMutex);

    qDebug("update");

    mRunning = true;
}

更新 3 行。问题有点复杂。我忘了我在线程中的访问数据部分也开始了一些子线程来填充数据结构

datathread {
    access data
}

thread {
    forever {
        if (Running) {
            LOCK
                if (!Running) leave

                forloop
                    start datathread to fill data to accessdata list
            UNLOCK
        }
        Running = false;
    }
}

update {
    Running = false;

    LOCK
        access data
    UNLOCK

    Running = true;
}

Answer 1

在write 期间重新启动read 方法的标准方法是使用seqlock。对于单个 writer 和 reader，seqlock 只是原子整数变量，每次 writer 启动和结束时都会递增。这样 reader 方法可以周期性地检查变量是否在 read 启动后没有改变：

atomic<int> seq = 0;

updater() // *writer*
{
    seq = seq + 1;
    <update data>
    seq = seq + 1;
}

thread() // *reader*
{
     retry: // Start point of unmodified data processing.
     {
         int seq_old = seq;
         if(seq_old & 1)
         {
              // odd value of the counter means that updater is in progress
              goto retry;
         }

         for(int i = 0; i < 10; i++)
         {
             <process data[i]>
             if(seq_old != seq)
             {
                 // updater has been started. Restart processing.
                 goto retry;
             }
         }
         // Data processing is done.
     }
}

如果多个 updater() 可以同时执行，整个update 代码应该使用互斥锁执行：

updater() // *writer*
{
    QMutexLocker locker(&updater_Mutex);

    seq = seq + 1;
    <update data>
    seq = seq + 1;
}

如果更新时甚至不能同时访问单个数据元素，则<update data> 和<process data[i]> 都应该在执行时使用互斥锁。