标签: asynchronous

有人可以解释这对同步方法意味着什么吗？如果我尝试改变方法async然后VS抱怨它.

这有效:

public Task MethodName()
{
     return Task.FromResult<object>(null);
}

这不起作用:

public async Task MethodName()
{
     return Task.FromResult<object>(null);
}

所以基本上我想知道这究竟是什么意思: Task.FromResult<object>(null);

我想删除一些mongodb集合,但这是一个异步任务.代码将是:

var mongoose = require('mongoose');

mongoose.connect('mongo://localhost/xxx');

var conn = mongoose.connection;

['aaa','bbb','ccc'].forEach(function(name){
    conn.collection(name).drop(function(err) {
        console.log('dropped');
    });
});
console.log('all dropped');

控制台显示:

all dropped
dropped
dropped
dropped

all dropped在删除所有集合后,最简单的方法是打印什么？任何第三方都可用于简化代码.

nodejs async模块:https://github.com/caolan/async提供了2 种类似的方法,async.waterfall和async.series.

他们之间有什么区别？

我正在写一个chrome扩展名.我想jQuery在我的扩展中使用.我没有使用任何背景页面,只是一个后台脚本.

这是我的文件:

manifest.json

{
    "manifest_version": 2,

    "name": "Extension name",
    "description": "This extension does something,",
    "version": "0.1",

    "permissions": [
        "activeTab"
    ],

    "browser_action": {
        "default_icon": "images/icon_128.png"
    },

    "background": {
        "scripts": ["background.js"],
        "persistent": false
    },

    "icons": {
        "16": "images/icon_16.png",
        "48": "images/icon_48.png",
        "128": "images/icon_128.png"
    }
}

我的background.js文件只运行另一个名为的文件work.js

// Respond to the click on extension Icon
chrome.browserAction.onClicked.addListener(function (tab) {
    chrome.tabs.executeScript({
        file: 'work.js'
    });
});

我的扩展的主要逻辑是在里面work.js.我认为这个问题的内容并不重要.

我想问的是如何在扩展中使用jQuery.因为我没有使用任何背景页面.我不能只是添加jQuery.那么如何在我的扩展中添加和使用jQuery呢？

我尝试从background.js文件中运行jQuery和我的work.js.

// Respond to the click …

我已经尝试了一段时间来获得一些我认为可以简单地使用.NET 4.5的东西

我想同时启动两个长时间运行的任务,并
以最佳的C#4.5(RTM)方式收集结果

以下作品,但我不喜欢它,因为:

• 我想Sleep成为一个异步方法,所以它可以是await其他方法
• 它看起来很笨拙 Task.Run()
• 我认为这甚至根本不使用任何新的语言功能!

工作代码:

public static void Go()
{
    Console.WriteLine("Starting");

    var task1 = Task.Run(() => Sleep(5000));    
    var task2 = Task.Run(() => Sleep(3000));

    int totalSlept = task1.Result + task2.Result;

    Console.WriteLine("Slept for a total of " + totalSlept + " ms");
}

private static int Sleep(int ms)
{
    Console.WriteLine("Sleeping for " + ms);
    Thread.Sleep(ms);
    Console.WriteLine("Sleeping for " + ms + " FINISHED");
    return ms;
}

非工作代码:

更新:这实际上是有效的,并且是正确的方法,唯一的问题是 Thread.Sleep

此代码不起作用,因为调用Sleep(5000)立即启动任务运行,因此Sleep(1000) …

它与这个问题松散相关:std :: thread是否在C++ 11中汇集？.虽然问题不同,但意图是一样的:

问题1:使用您自己的(或第三方库)线程池以避免昂贵的线程创建仍然有意义吗？

另一个问题的结论是你不能依赖于std::thread汇集(可能或可能不是).但是,std::async(launch::async)似乎有更高的机会被汇集.

它不认为它是由标准强制,但恕我直言,如果线程创建缓慢,我会期望所有好的C++ 11实现都会使用线程池.只有在创建新线程成本低廉的平台上,我才会期望它们总是产生一个新线程.

问题2:这正是我的想法,但我没有事实证明这一点.我很可能会弄错.这是一个有根据的猜测吗？

最后,在这里我提供了一些示例代码,首先展示了我认为线程创建如何表达async(launch::async):

例1:

 thread t([]{ f(); });
 // ...
 t.join();

变

 auto future = async(launch::async, []{ f(); });
 // ...
 future.wait();

示例2:消防和遗忘线程

 thread([]{ f(); }).detach();

变

 // a bit clumsy...
 auto dummy = async(launch::async, []{ f(); });

 // ... but I hope soon it can be simplified to
 async(launch::async, []{ f(); });

问题3:您希望async版本的thread版本？

其余的不再是问题的一部分,只是为了澄清:

为什么必须将返回值赋给虚拟变量？

不幸的是,当前的C++ 11标准强制您捕获返回值std::async,否则执行析构函数,直到操作终止为止.有人认为这是标准中的一个错误(例如,Herb Sutter). …

我最近一直在看Go的goroutines,并认为在Java中有类似的东西会很好.据我所知,并行化方法调用的常用方法是执行以下操作:

final String x = "somethingelse";
new Thread(new Runnable() {
           public void run() {
                x.matches("something");             
    }
}).start();

那不是很优雅.有没有更好的方法呢？我在项目中需要这样的解决方案,所以我决定围绕异步方法调用实现自己的包装类.

我在J-Go发布了我的包装类.但我不知道这是不是一个好的解决方案.用法很简单:

SampleClass obj = ...
FutureResult<Integer> res = ...
Go go = new Go(obj);
go.callLater(res, "intReturningMethod", 10);         //10 is a Integer method parameter
//... Do something else
//...
System.out.println("Result: "+res.get());           //Blocks until intReturningMethod returns

或者更简洁:

Go.with(obj).callLater("myRandomMethod");
//... Go away
if (Go.lastResult().isReady())                //Blocks until myRandomMethod has ended
    System.out.println("Method is finished!");

在内部,我正在使用一个实现Runnable的类,并做一些Reflection工作来获取正确的方法对象并调用它.

我想对我的小型库以及在Java中进行这样的异步方法调用的主题有所了解.安全吗？有没有更简单的方法？

我知道使用fire-and-forget async void方法来启动任务通常被认为是一个坏主意,因为没有跟踪任务的跟踪,处理可能在这种方法中抛出的异常是很棘手的.

我一般应该避免使用async void事件处理程序吗？例如,

private async void Form_Load(object sender, System.EventArgs e)
{
        await Task.Delay(2000); // do async work
        // ...
} 

我可以像这样重写它:

Task onFormLoadTask = null; // track the task, can implement cancellation

private void Form_Load(object sender, System.EventArgs e)
{
        this.onFormLoadTask = OnFormLoadTaskAsync(sender, e);
} 

private async Task OnFormLoadTaskAsync(object sender, System.EventArgs e)
{
        await Task.Delay(2000); // do async work
        // ...
} 

除了可能的重入之外,异步事件处理程序的水下岩石是什么？

Rebol 3中的所有端口操作都是异步的.我可以找到进行同步通信的唯一方法是调用wait.

但是在这种情况下调用wait的问题是它将检查所有开放端口的事件(即使它们不在传递给等待的端口块中).然后他们调用响应事件处理程序,但可以在其中一个事件处理程序中完成读/写操作.这可能导致递归调用"等待".

我该如何解决这个问题？

我正在阅读Stephen Cleary撰写的"C#Cookbook中的并发",我注意到以下技巧:

var completedTask = await Task.WhenAny(downloadTask, timeoutTask);  
if (completedTask == timeoutTask)  
  return null;  
return await downloadTask;  

downloadTask是对httpclient.GetStringAsync的调用,timeoutTask正在执行Task.Delay.

如果它没有超时,则downloadTask已经完成.为什么有必要做第二次等待而不是返回downloadTask.Result,因为任务已经完成了？