相关疑难解决方法(0)

并发是在不同的线程上并行运行两个任务.但是,异步方法并行运行,但在同一个线程上运行.这是如何实现的？那么,并行性呢？

这3个概念之间有什么区别？

我最近正在阅读关于async/await的事情,我对以下事实感到困惑:我正在阅读的许多文章/帖子说明在使用异步等待时没有创建新线程(示例).

我创建了一个简单的控制台应用程序来测试它

class Program
    {
        static  void Main(string[] args)
        {
            Console.WriteLine("Main: " + Thread.CurrentThread.ManagedThreadId);
            MainAsync(args).Wait();
            Console.WriteLine("Main End: " + Thread.CurrentThread.ManagedThreadId);

            Console.ReadKey();
        }


        static async Task MainAsync(string[] args)
        {
            Console.WriteLine("Main Async: " + Thread.CurrentThread.ManagedThreadId);

            await thisIsAsync();
        }

        private static async Task thisIsAsync()
        {
            Console.WriteLine("thisIsAsyncStart: " + Thread.CurrentThread.ManagedThreadId);
            await Task.Delay(1);
            Console.WriteLine("thisIsAsyncEnd: " + Thread.CurrentThread.ManagedThreadId);

        }
    }

以下代码的输出是:

Main: 8
Main Async: 8
thisIsAsyncStart: 8
thisIsAsyncEnd: 9
Main End: 8

我错过了这一点,或者这个AsyncEnd是否具有与其他操作不同的线程ID？

编辑:

我已根据下面的答案更新了代码await Task.Delay(1),但我仍然看到相同的结果.

引用下面的答案:

Rather, it enables the …

在任何情况下是否有理由选择 Parallel.ForEach 而不是 wait ForEachAsync（反之亦然）？或者它们实际上是相同的？

await collection.ForEachAsync( m => { m.DoSomething(); } );

VS

Parallel.ForEach( collection, m => { m.DoSomething(); } );

我最初在Stackoverflow和谷歌搜索了类似的问题.只有一个链接给了一些点,但我无法理解清楚.[ 1 ]

以下问题困扰着我:

1. 在异步编程中,什么是真正的Callback方法？代表？

2. 异步程序的实现是使用多线程？

如果提供图形解释,我将非常感激

[ 1 ] "多线程和异步编程之间的区别"

是使用async和await原油人的主题？

许多个月前，我学会了如何在 Android 上编写多线程 Java 代码。我记得我必须创建线程、启动线程等。

现在我正在学习 Javascript，我刚刚了解了async和await。

例如：

async function isThisLikeTwoThreads() {
 const a = slowFunction();
 const b = fastFunction();
 console.log(await a, await b);
}

这看起来比我以前做的更简单，而且更直观。

slowFunction()将先启动，然后fastFunction()将启动，并且console.log()会等到这两个功能记录之前解决-和slowFunction()并fastFunction()在同一时间都可能运行。我希望它最终在浏览器上是否这些是单独的线程。但它看起来像粗略的多线程一样走路和说话。是吗？

我目前正在尝试用 Godot C# 制作一个基本的射手，对于枪的射速，我一直在尝试不同的延迟系统。尽管我试图使脚本通用，但节点计时器仍然有效，并且计时器调用似乎只调用父脚本中的函数。

我现在正在研究 C# 的 Task.Delay 方法，它似乎也可以工作，因为它是一个异步操作，它看起来不会受到帧速率的影响或减慢游戏速度。

我的问题是，在游戏应用程序中使用 Task.Delay 是否存在任何已知问题：比如它是否不可靠，或者如果调用该方法的实例过多，它会崩溃吗？

这是下面的代码，尽管我认为它\xe2\x80\x99s 并不重要：

 private void shoot() {\n  //if "canShoot" spawn bullet\n  ShootCooledDown();\n}\n\nprivate async void ShootCooledDown() {\n  TimeSpan span = TimeSpan.FromSeconds((double)(new decimal(shotDelay)));\n  canShoot = false;\n  await Task.Delay(span);\n  canShoot = true;\n}  \n

我正在学习异步和等待在编程中如何工作。我在互联网上看到这个例子，说这是异步代码：

class Program
{
    static async Task Main(string[] args)
    {
        Method2();
        var count = await Method1();
        Method3(count);
        Console.ReadKey();
    }

    static async Task<int> Method1()
    {
        int count = 0;
        await Task.Run(() =>
        {
            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine(" Method 1");
                count += 1;
            }
        });
        return count;
    }

    static void Method2()
    {
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine(" Method 2");
        }
    }

    static void Method3(int count)
    {
        Console.WriteLine("Total count is …

好的，我想我几乎可以理解所有的模糊测试async / await和多线程了。我知道异步与任务有关，多线程与工作人员有关。因此，您可以在同一线程上运行不同的任务（此答案在解释它方面做得很好）。

因此，我制作了一个小程序以查看魔术的发生，但我感到有些困惑：

public class Program
{
    public static async Task Main(string[] args)
    {
        var task = ToastAsync();
        Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] Cleaning the kitchen...");
        await task;
        Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] Take the toast");
    }

    public async static Task ToastAsync()
    {
        Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] Putting the toast");
        Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] Setting a timer");
        await Task.Delay(2000);
        Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] Toast is ready");
    }
}

在第一次运行该程序之前，我希望它可以在单个线程上运行。就像我上面链接的答案一样，我希望这相当于“在烤面包机的计时器运行时打扫厨房”。结果虽然矛盾：

[1] Putting the toast
[1] Setting a timer
[1] Cleaning the kitchen...
[4] Toast is ready
[4] Take the toast

上面的结果对我来说意义不大。到底发生了什么事？似乎该功能的一部分正在一个线程中执行，然后，当await到达某个点时，它将处理执行到另一个线程...？我什至不知道这是可能的D： …

在现代浏览器中运行的 Javascript 中，我希望对函数进行非阻塞调用。

有人指出 Promises 以及构建在它们之上的异步函数，但我发现 Promises（以及异步函数）确实会阻塞。请参阅下面的代码来演示这一点。

唯一不阻塞的函数似乎是内置的。例如 setTimeout。这似乎就是我发现的所有“非阻塞”Promise 示例都使用 setTimeout 的原因。执行的单个线程会遍历超时代码并调用非阻塞 setTimeout，以便继续执行。Promise 本身只是组织回调，这很好，但它们本身并不会导致调用非阻塞。

webworker 解决方案似乎没有引用，因此无法修改调用者的数据。序列化、调用网络工作者，然后反序列化以获取结果将是相当低效且复杂的。

这是从 Promise 获取“非阻塞”行为的典型示例，但如果您在 Web 控制台中单步执行它，您将看到唯一不阻塞的是 setTimeout。

<!DOCTYPE html>
<head>
  <meta charset="UTF-8">
</head>
<body>
  <script>
    'use strict';

    function wait_setTimeout(call_when_finished){
      console.log("entering wait_setTimeout");
      setTimeout(call_when_finished, 2000); // 3 second delay
    }
    function wait_setTimeout_resolve(){
      console.log("wait_setTimeout_resolved");
    }

    console.log("before wait_setTimeout promise");
    let p0 = new Promise((wait_setTimeout_resolve) => {
      this.wait_setTimeout(wait_setTimeout_resolve);
    });
    console.log("after new Promise(wait_setTimeout_resolve)");
    p0.then(() => console.log("then wait_setTimeout_promise target"));
    console.log("after wait_setTimeout_promise.then");
    /*
     before wait_setTimeout promise
     entering wait_setTimeout
     after new Promise(wait_setTimeout_resolve)
     after wait_setTimeout_promise.then …

我最近一直在尝试了解线程、线程安全，并遇到了一个非常大的术语“异步编程”。这完全让我陷入了困惑，想知道是否有人可以解答我对此的一些疑问，因为它确实让我感到困惑。

在此之前，我认为“异步”的定义是不会同时发生，而同时发生的术语就是“同步”。

如果你谷歌一下，它实际上确实是这样说的，但现在我了解到异步编程就是同时发生两件事，至少在我看来是这样。

我一直在观看有关这一切的 YouTube 视频系列，他们解释说，编程中的异步就是在不影响主 UI 线程的情况下运行多个事物。

现在，我了解线程，您创建一个新线程并将其添加到线程池中，线程的运行取决于计算机上的核心数量，并且它们都运行很短的时间，以创建所有线程都并行运行的错觉。

让我困惑的是异步编程，现在我被告知创建一个新任务是异步编程，异步编程是否仅仅意味着您在新线程上进行编码，因为到目前为止，两个操作同时运行的唯一方法时间是当它们在不包括主线程（UI 线程）的其他 2 个线程上运行时。现在我想知道还有什么使线程..是它在自己的线程上运行这一事实使其成为异步编程的一部分还是我错过了其中的很大一部分？

谁能帮我解决这个问题吗？

我有一个异步方法，它调用另一个异步方法，但是，我希望它在单独的线程上并行运行：

public async Task<Page> ServePage() {
  Task.Run(() => DoThings(10));   // warning here

  // ... other code
  return new Page();
}

public async Task DoThings(int foo) {
  // stuff
}

警告指出：

由于不等待此调用，因此在调用完成之前将继续执行当前方法。考虑将“await”运算符应用于调用结果。

事实上，这就是我正在努力做的事情。为什么我会收到编译器警告？Task.Run 的语法是否不正确？