标签: busy-waiting

对于相同的情况，自旋等待、自旋循环和忙自旋是否是不同的名称？

我阅读了不同的线程，它们似乎都与一个“忙”检查资源可用性的循环有关。

我的程序通过使用空闲的工作线程将多行文本打印到控制台。然而，问题是工作线程在打印文本之前没有等待前一个工作线程完成，这导致文本被插入到另一个工作线程的文本中，如下图所示：

我需要通过使用 std::condition_variable 来解决这个问题——称为忙等待问题。我已经尝试在下面的代码中实现 condition_variable，基于在这个链接上找到的例子，下面的 stackoverflow 问题对我有帮助，但还不够，因为我对 C++ 的一般知识有限。所以最后我只是把所有的东西都注释掉了，我现在不知所措。

// threadpool.cpp
// Compile with:
// g++ -std=c++11 -pthread threadpool.cpp -o threadpool

#include <thread>
#include <mutex>
#include <iostream>
#include <vector>
#include <deque>

class ThreadPool; // forward declare
//std::condition_variable cv;
//bool ready = false;
//bool processed = false;

class Worker {
public:
    Worker(ThreadPool &s) : pool(s) { }
    void operator()();
private:
    ThreadPool &pool;
};

class ThreadPool {
public:
    ThreadPool(size_t threads);
    template<class F> void enqueue(F f);
    ~ThreadPool(); …

我花了最后20分钟对空循环进行研究,其目的只是等待条件变为真.

我有一个名为"waitForLoaded"的函数,它是由CreateThread创建的一个线程.

功能:

void waitForLoaded(){
    while(!isLoaded){
        Sleep(500); // < my question
    }
    Sleep(500); //sleep another 500ms to ensure everything is loaded.
    //continue on here
}

我使用Sleep(500)在CPU上很容易,因为我认为使用0或1会耗尽处理器.

我在许多人看到过使用"睡眠(0)"的代码,我从来不明白为什么不能完全没有睡觉并且做"while(condition){} .."

我找不到任何更加CPU友好的可靠答案所以我在这里问人们,忙碌等待0ms,1ms或500ms之间有什么区别,哪个更适合CPU.

在我看来,最好做至少一半的睡眠,这是用户几乎无法察觉的.

我有两个文件，都是 1 字节大（只包含“1”或“0”）。

现在在用 Clojure 编写的程序的主循环中，我想等到其中一个文件发生更改后再继续。这可以通过忙等待来完成，使用 slurp 轮询文件的更改。但这是一种资源浪费。

我怎么能不忙着等待呢？

在Go中,我可以time.After用来超时睡眠功能,但我不能对忙碌等待(或工作)的功能做同样的事情.以下代码timed out在一秒钟后返回,然后挂起.

package main

import (
        "fmt"
        "time"
)

func main() {
        sleepChan := make(chan int)
        go sleep(sleepChan)
        select {
        case sleepResult := <-sleepChan:
                fmt.Println(sleepResult)
        case <-time.After(time.Second):
                fmt.Println("timed out")
        }

        busyChan := make(chan int)
        go busyWait(busyChan)
        select {
        case busyResult := <-busyChan:
                fmt.Println(busyResult)
        case <-time.After(time.Second):
                fmt.Println("timed out")
        }
}

func sleep(c chan<- int) {
        time.Sleep(10 * time.Second)
        c <- 0
}

func busyWait(c chan<- int) {
        for {
        }
        c <- 0
}

为什么在第二种情况下超时没有触发,我需要用什么替代方法来中断工作goroutines？

我正在研究Youtube Mp3转换器.Mp3转换需要几秒钟,我希望用户无法单击表单上的任何控件.我已经完成Control.Enabled = false了所有控制的使用,但我认为这种方式不专业,似乎不适合视觉.有没有什么好方法可以做到这一点？

我正在编写Leslie Lamport 的 Bakery 算法的 Go 实现，该算法具有 busy-spin-waits 来处理一些最大数量的线程。

我正在编写一个 go 函数，除非满足特殊条件，否则该函数不应继续。到目前为止，我的代码如下所示：

func acquireLock() {
    ...
    for specialConditionIsFalse {
    }
    ...
}

有没有更有效的方法来停止处理这个线程？