相关疑难解决方法(0)

并发和并行有什么区别？

赞赏的例子.

我认为它们基本上是相同的 - 编写在处理器之间分割任务的程序(在具有2个以上处理器的机器上).然后我正在阅读https://msdn.microsoft.com/en-us/library/hh191443.aspx,其中说

异步方法旨在实现非阻塞操作.异步方法中的await表达式在等待的任务运行时不会阻止当前线程.相反,表达式将方法的其余部分作为延续进行注册,并将控制权返回给异步方法的调用者.

async和await关键字不会导致创建其他线程.异步方法不需要多线程,因为异步方法不能在自己的线程上运行.该方法在当前同步上下文上运行,并仅在方法处于活动状态时在线程上使用时间.您可以使用Task.Run将CPU绑定的工作移动到后台线程,但后台线程无助于正在等待结果可用的进程.

我想知道是否有人可以为我翻译成英文.它似乎区分了异步性(是一个单词？)和线程,并暗示你可以拥有一个具有异步任务但没有多线程的程序.

现在我理解异步任务的想法,例如pg上的示例.Jon Skeet的C#In Depth,第三版中的 467

async void DisplayWebsiteLength ( object sender, EventArgs e )
{
    label.Text = "Fetching ...";
    using ( HttpClient client = new HttpClient() )
    {
        Task<string> task = client.GetStringAsync("http://csharpindepth.com");
        string text = await task;
        label.Text = text.Length.ToString();
    }
}

该async关键字的意思是" 这个功能,无论何时它被调用时,不会在这是需要的一切它的完成被称为它的呼叫后,上下文调用."

换句话说,将它写在某个任务的中间

int x = 5; 
DisplayWebsiteLength();
double y = Math.Pow((double)x,2000.0);

,因为DisplayWebsiteLength()与"无关" x或y将导致DisplayWebsiteLength()"在后台"执行,如

                processor 1                |      processor 2
-------------------------------------------------------------------
int …

我发现TaskCompletionSource.SetResult();在返回之前调用等待任务的代码.在我的情况下,导致死锁.

这是一个在普通版本中启动的简化版本 Thread

void ReceiverRun()
    while (true)
    {
        var msg = ReadNextMessage();
        TaskCompletionSource<Response> task = requests[msg.RequestID];

        if(msg.Error == null)
            task.SetResult(msg);
        else
            task.SetException(new Exception(msg.Error));
    }
}

代码的"异步"部分看起来像这样.

await SendAwaitResponse("first message");
SendAwaitResponse("second message").Wait();

Wait实际上嵌套在非异步调用中.

SendAwaitResponse(简化)

public static Task<Response> SendAwaitResponse(string msg)
{
    var t = new TaskCompletionSource<Response>();
    requests.Add(GetID(msg), t);
    stream.Write(msg);
    return t.Task;
}

我的假设是第二个SendAwaitResponse将在ThreadPool线程中执行,但它会在为ReceiverRun创建的线程中继续.

无论如何设置任务的结果而不继续等待代码？

应用程序是一个控制台应用程序.

在文档中，Dart 是单线程的，但是为了一次执行两个操作，我们使用与线程相同的未来对象。

使用 Future 对象（期货）来执行异步操作。

如果 Dart 是单线程的，那么为什么它允许执行异步操作。

注意：异步操作是并行操作，称为线程

考虑以下我将同步等待的异步方法。等一下，我知道。我知道这被认为是不好的做法并导致死锁，但我完全意识到这一点，并采取措施通过用Task.Run包装代码来防止死锁。

    private async Task<string> BadAssAsync()
    {
        HttpClient client = new HttpClient();

        WriteInfo("BEFORE AWAIT");

        var response = await client.GetAsync("http://google.com");

        WriteInfo("AFTER AWAIT");

        string content = await response.Content.ReadAsStringAsync();

        WriteInfo("AFTER SECOND AWAIT");

        return content;
    }

这段代码肯定会死锁（与SyncronizationContext环境-它就像ASP.NET单个线程调度任务），如果调用这样的：BadAssAsync().Result。

我面临的问题是，即使使用这个“安全”包装器，它仍然偶尔会出现死锁。

    private T Wait1<T>(Func<Task<T>> taskGen)
    {
        return Task.Run(() =>
        {
            WriteInfo("RUN");

            var task = taskGen();

            return task.Result;
        }).Result;
    }

这些“WriteInfo”行是故意的。这些调试行让我看到它偶尔发生的原因是 中的代码Task.Run，有些神秘，是由开始服务请求的同一个线程执行的。这意味着它具有 AspNetSynchronizationContext 作为SyncronizationContext并且肯定会死锁。

这是调试输出：

***（工作正常）
开始：TID：17；SCTX：System.Web.AspNetSynchronizationContext；调度程序：System.Threading.Tasks.ThreadPoolTask​​Scheduler
运行：TID：45；SCTX：<null> 调度程序：System.Threading.Tasks.ThreadPoolTask​​Scheduler
等待之前：TID：45；SCTX：<null> 调度程序：System.Threading.Tasks.ThreadPoolTask​​Scheduler
等待后：TID：37；SCTX：<null> 调度程序：System.Threading.Tasks.ThreadPoolTask​​Scheduler
第二次等待后：TID：37；SCTX：<null> 调度程序：System.Threading.Tasks.ThreadPoolTask​​Scheduler

***（死锁）
开始：TID：48；SCTX：System.Web.AspNetSynchronizationContext；调度程序：System.Threading.Tasks.ThreadPoolTask​​Scheduler …

我有一个小问题.

我承认在.Net 4.5之前我没有多次使用多线程,但是有了新的async/await功能,我决定尝试一下.我开始尝试它,一切似乎都很好,但我无法在网络上的任何地方找到解决我的"问题"的方法.

所以每个人都解释了如何await使用.Net平台的新转换方法(例如WriteAsync(),ReadAsync()等等),但是如果我想将它用于我自己的方法呢？例如,假设我正在执行一项极其昂贵的计算,并且希望我的所有4个内核都在使用它.我会有类似的东西:

async Task DoLotsOfWork<T>(T[] data, int start, int end)
{
    //Do very expensive work
}

但由于我没有await关键字,因此该方法仅被视为同步方法.我想从外面调用它4次,以便它可以在我的所有核心上运行,同时我向用户显示一些合理的东西(例如"请等待......").我能够弄清楚的唯一解决方案是await Task.Yield();在方法的开头添加一个.像这样的东西:

async Task DoLotsOfWork<T>(T[] data, int start, int end)
{
    await Task.Yield();
    //Do very expensive work
}

在这种情况下,该方法将按照我的预期行事.但是有更好的解决方案吗？我觉得应该比编写那行代码更容易/更明智.我知道我可以创建一个Task/Thread对象并调用该Start()方法,但这需要更多的工作.我只是认为使用新的异步/等待功能这种事情会更容易.

我有一些关于使用torch.multiprocessing模块的问题。假设我有一个torch.nn.Module电话model，我打电话model.share_memory()给它。

如果两个线程同时调用forward(), 即会发生什么情况model(input)？安全吗？或者我应该使用锁定机制来确保model多个线程不会同时访问？类似地，如果两个或多个线程有一个优化器工作model.parameters()并且它们同时调用会发生什么optimizer.step()？

我问这些问题是因为我经常看到在optimizer.step()没有锁定机制的共享模型上被调用（即在 A3C 或 ACER 的 RL 实现中），我想知道这样做是否安全。

异步示例很有用,但作为Rust和Tokio的新手,我正在努力研究如何一次执行N个请求,使用向量中的URL,并为每个URL创建响应HTML的迭代器作为字符串.

怎么可以这样做？

我有一些异步函数

async fn get_player(name: String, i: Instant) -> Option<Player> {
// some code here that returns a player structs
}

在我的主函数中，我想在循环中同时运行上述函数，该函数大约需要 1 秒才能完成，并且我需要运行它至少 50 次，因此我想让它同时运行该函数 50 次。在我的主函数中，我有一个lazy_static自定义Client结构，该结构不应创建多次。

主功能

#[tokio::main]
async fn main() {
    client.init().await;

    println!("start");
    for i in 0..10 {
        println!("{}", i);
        let now = Instant::now();

        tokio::spawn(async move  {
            client.get_player("jay".to_string(), now).await;
        });
    }
    loop {}
}

我传递即时的原因是因为在我的 get_player 函数中我有一个 println!() 只打印执行时间。

上面的 main 方法每个函数调用大约需要 500ms，但是下面的代码只需要 100ms。

#[tokio::main]
async fn maain(){
    client.init().await;

    for i in 0..10 {
        let now …

我的场景是这样的

//a lot of database dependant processing

db.SaveChangesAsync(); //asynchronouly saving database changes

//a lot of ANOTHER long term database INDEPENDANT stuff

因为await db.SaveChangesAsync（）等待直到对数据库进行了所有更改（可能要花一些时间）并且我不想等待，但是在paralell中，我想在WAVE之前使其他日志项保存SaveChanges正在保存更改，为什么我应该使用等待吗？如果我不使用await，则会在下图中收到磨损的信息。

我想弄清楚为什么这两个异步方法不能并行工作。请注意，每个方法都会返回一些 html，并且对于其中的这个 Iteration（它的演示代码）（原始代码在我的 .Net 项目中）。

每种方法都需要 9 秒才能完成。

这两种方法都是异步的，即使它在单个方法中调用和运行也需要 18 秒才能完成。这意味着它不会并行运行。

总的来说，我想要的是，完成这两种方法应该需要 9 秒。怎么可能？请建议并行运行这两种方法。（我想要这个，因为在我的项目中，一个方法中有很多方法，我希望所有方法都并行运行）

提前致谢。

请查看以下代码：

namespace LearnAynchStackOverflow
{
class Program
{
    static async Task Main(string[] args)
    {
        var startTime = DateTime.Now;
        Console.WriteLine($"Start time: {startTime}");

        var emailHtml = EmailTemplate.EmailHtml();
        var smsHtml = SmsTemplate.SmsHtml();

        var f = await Task.WhenAll(emailHtml, smsHtml);

        var endTime = DateTime.Now;
        Console.WriteLine($"End time: {endTime}");

        Console.ReadLine();
    }
}

public class EmailTemplate
{
    //This method takes 9 seconds to complete
    public static async Task<string> EmailHtml()
    {
        string str = string.Empty; …