标签: blocking

我可以用来select()确定对 的调用是否recv()会阻塞，但是一旦我确定有要读取的字节，是否有办法在实际调用之前查询当前有多少字节可用recv()？

我正在使用twsited的INotify监视/ dev目录以监视正在添加的新串行设备.我目前使用的代码类似于下面的代码.

notifier = INotify()
notifier.watch(FilePath("/dev"), IN_CREATE, callbacks=[self.created])
notifier.startReading()

def created(self, ignored, path, mask):
    ...
    blocking code
    ...

我现在遇到的问题是当'created'被调用时,它阻塞了我的反应器,所以其他网络会话(我有同一个反应器的TCP和UDP连接)必须等待'created'方法完.

有谁知道如何让"创建"方法在后台运行,所以它不会阻止我的反应堆？

谢谢,

西蒙

我想我刚刚发现了一些与node.js或浏览器相关的东西.所以node.js应该是非阻塞的,但是一个简单的setTimeout阻塞了同一个客户端的整个网站.

这是服务器代码:

// Create HTTP Server
var http = require('http');

// Create page number holder
var page = 0;

http.createServer(function (req, res) {
    // Increment Page Number
    page++; 

    // Log page load
    console.log('LOAD PAGE', page); 

    // Set response header
    res.writeHead(200, {'Content-Type': 'text/plain'}); 

    // Wait 10 seconds and write Hello World message to client.
    setTimeout(function(){ res.end('Hello World\n'); }, 10000); 

}).listen(5000); // Listen on port 5000

// Log server start
console.log('Server running on port 5000.');

所以我所说的是当我尝试使用两个选项卡在Chrome(版本25.0.1364.152)中打开http://mysite.com:5000/时,第一个选项卡必须在节点处理第二个选项卡之前完成.js文件.

它看起来像这样:

Client: Open Tab1 …

我正在尝试找到一种方法来缓存使用最近对算法（暂时强力）的应用程序的元素数组。根据《缓存性能和阻塞算法优化》论文，它说：

分块是一种用于提高内存层次结构有效性的通用优化技术。通过在更快的层次结构中重用数据，可以减少平均访问延迟。它还减少了对层次结构中较慢级别的引用数量。因此，阻塞优于预取等优化，后者隐藏了延迟，但不会降低内存带宽要求。这种减少对于多处理器尤其重要，因为内存带宽通常是系统的瓶颈。分块已被证明对于线性代数中的许多算法都很有用。

论文给出了一个矩阵乘法代码，并将其修改为阻塞，减少缓存未命中：

for kk = 1 to N by B
  for j = 1 to N by B
    for i = 1 to N
      for k = kk to min(kk + B-1, N)
         r = X[i,k];  // register allocated
         for j = jj to min(jj + B-1, N)
           Z[i,j] += r * Y[k,j];

这里，B是分块因子，但我们如何确定它呢？是否有通用方法来查找 cpu 缓存可以处理的特定限制？可能不是所有的CPU都有相同的缓存。通用程序说：

• 首先是重构代码以阻止那些进行重用的循环。
• 其次是选择最大化局部性的阻塞因子。

最接近配对算法（暴力）是：

minDist = infinity
for i = 1 to length(P) - 1
  for j …

我为每个信号（SIGCHLD、SIGTSTP、SIGINT）设置了一个处理程序，现在我需要在某些处理程序运行时阻止其他信号。
有一些资源，如sigaction(2)和Blocking for Handler，但我不明白在我的情况下我应该做什么或如何使用代码。
小信息：
处理程序：sigchldHandler, sigintHandler, sigtstpHander =>signals.c
有一个名为 smash.c 的文件，它包含一个无限循环以始终获取命令。
提前致谢

这个问题解释了如何System.in在运行任务时使用来运行项目中的特定类。

但对我来说，目前它不起作用：尽管我已将application插件和以下几行包含在build.gradle：

mainClassName = "misc.StreamsExp"
run{ 
    standardInput = System.in 
}
task stream( type: JavaExec, dependsOn: assemble ){
    classpath sourceSets.main.runtimeClasspath
    main = "misc.StreamsExp"
}

下面的应用程序代码中的行readLine应该是阻塞的，但事实并非如此：

BufferedReader br = new BufferedReader(new InputStreamReader( System.in ));

String enteredLine = "";
while( enteredLine == null || ! enteredLine.equals( "q" )){
    System.out.println( "spuds");
    enteredLine = br.readLine();
}

...相反，事情会永远旋转：

土豆土豆
土豆
土豆
...

注意，我使用的是 Windows 10 操作系统，带有 Java 8.91。我尝试过 Windows DOS 控制台和 Cygwin。
NB2 当我在 Eclipse（Gradle STS Eclipse …

假设我们有一个 ASP.NET Core 接收一个字符串作为有效负载，大小为几兆字节。第一种方法实现：

[HttpPost("updateinfos")]
public async Task UpdateInfos()
{
    var len = (int)this.Request.ContentLength;
    byte[] b = new byte[len];
    await this.Request.Body.ReadAsync(b,0,len);
    var content = Encoding.UTF8.GetString(b);
    .....
}

正文是用 读取的ReadAsync，这很好，因为我们在套接字上有 I/O 内容，并且由于调用本身的性质，异步是免费的。但如果我们仔细观察，就会发现该GetString()方法纯粹是 CPU 的，并且是线性复杂度的阻塞。无论如何，这会以某种方式影响性能，因为其他客户端等待我的字节转换为字符串。GetString()我认为为了避免这种情况，解决方案是在线程池上运行 ，方法是：

[HttpPost("updateinfos")]
public async Task UpdateInfos()
{
    var len = (int)this.Request.ContentLength;
    byte[] b = new byte[len];
    await this.Request.Body.ReadAsync(b,0,len);
    var content = await Task.Run(()=>ASCIIEncoding.UTF8.GetString(b));
    .....
}

请不要介意现在的返回，函数中还需要做更多的事情。

那么问题来了，第二种方法是不是太过分了？如果是这样，区分什么可以作为阻塞运行以及什么必须移动到另一个线程的边界是什么？

scala.io.StdIn.readLine() 是阻塞调用吗？

从文档中，没有提到它是一个阻塞调用。

我想做这样的事情：

while(true){
    val input = scala.io.StdIn.readLine()
    input match{
        case "quit" =>
            ...
        case "stats" =>
            ...
        case _ =>
            ...
    }
}

如果它不阻塞，它会不断循环，将输入设置为空，并每次触发case _吗？

如果它被阻止，为什么它没有显示在文档中？或者我在哪里可以看到说它是阻塞的定义？

一般来说，我怎么知道一个方法是否阻塞？

我预计下面的代码会被阻塞近 5 秒，但事实并非如此。它立即打印出来。Result操作不是阻塞的吗？

class Program
{
    static void Main()
    {
        // Return a value type with a lambda expression
        Task<int> task1 = Task<int>.Factory.StartNew(() => Task.Delay(5000).Id + 100);
        int i = task1.Result;
        Console.WriteLine(i);
    }
}

有人会这样做吗？它只会阻塞直到第一次连接尝试.