标签: asynchronous

什么是同步方法，什么是异步方法？同步和异步方法有什么区别？我什么时候必须使用同步或异步方法？我问这些问题是因为我不明白：

public async void ReadData(filepath)
{
    CreateDoc("hello");    //<------ Why I can't do that ?
}

public void CreateDoc(string astring)
{
    Debug.WriteLine(astring);
}

为什么我不能这样做？：

public async void ReadData(filepath)
{
     var BarreDroite = new string[] { "|" };
     foreach (string tableArret in items.Split(BarreDroite, StringSplitOptions.RemoveEmptyEntries))
     {
         listeArret.Add(tableArret); //<---- Here appear the problem.
     }
{

我问这个问题是因为我在网上找不到明确的解释。

以下是我编写的一小段代码,用于演示此问题的基础知识.

码

private async void Form1_Load( object sender, EventArgs e ) {
    var result = await TestAsyncMethodName();
}

private async Task<string> TestAsyncMethodName() {
    string name = "Method: " + System.Reflection.MethodBase.GetCurrentMethod().Name;

    int x = 0;
    foreach ( StackFrame sf in (new StackTrace()).GetFrames()) {
        x++;
        name = name + "\nStack Frame [" + x + "] : " + sf.GetMethod().Name;
    }

    await Task.Run( () => { name = name + "\nAnonymous Method: " + System.Reflection.MethodBase.GetCurrentMethod().Name; } );

    return name;
}

结果

Method: …

我正在学习 C# 异步，并试图准确了解使方法异步的影响是什么。

如果我有以下方法（非异步）：

public bool method()
{
     int a = 2 + 1;      //line 1
     string b = "test";  //line 2
     double c = 2.14;    //line 3
     return true;        //line 4
}

上面的方法中，编译器会依次执行每一行，比如先执行第1行，再执行第2行等

我的问题涉及添加异步对执行顺序的影响，如下所示。

public async Task<bool> method()
{
     int a = 2 + 1;      //line 1
     string b = "test";  //line 2
     double c = 2.14;    //line 3
     return true;        //line 4
}

添加 async 是否会导致编译器现在同时执行第 1、2、3 和 4 行？

如果是这样，如果我执行以下操作：

public async Task<bool> method()
{
     int a …

我对此代码感到困惑.根据包含此代码的文档,它会调用允许它们同时执行的每个任务,然后等待它们都完成.

我不明白执行的顺序是如何运作的.通过声明任务var firstTask = DoSomethingAsync();会导致任务开始执行吗？我认为没有await表达式它是同步的.

public async Task RunConcurrentTasks()
{
    var firstTask = DoSomethingAsync();
    var secondTask = DoSomethingElseAsync();

    await firstTask;
    await secondTask;
} 

此外,此代码是否实现了相同的结果？

public async Task RunConcurrentTasks()
{
    var firstTask = DoSomethingAsync();
    var secondTask = DoSomethingElseAsync();

    await Task.WhenAll(firstTask, secondTask);
}

这不是一个调试类型的问题,我只是在asycnchronous编程领域寻找一个特定的教育,一个我不可否认的领域,在这里.

我正在编写一个程序,我需要它来定期拨打电话,同时还要执行其他功能.我查找了如何编写一个异步方法来实现这一点,并实际上让它工作.

令我困惑的是,当我从我的Main方法调用它时,我得到一个警告,说我应该使用await关键字让程序等待方法调用完成,否则我可能无法得到预期的行为,这是对我很奇怪.我认为,编写异步方法的关键在于让它运行,然后继续前进而不等待它完成,因此注意警告会破坏目的.另一方面,我并不傲慢地认为我比开发Visual Studio的专业人员更了解并添加了警告,因此必须有更多情况下添加await关键字更有意义.

我的问题是:通常使用的异步方法如何保证听到此警告？

编辑:人员请求代码和警告的特定文本,因此:

异步方法:

public static async Task FindPairs(TimeSpan interval, CancellationToken cancellationToken)
            {
            while (true)
                {
                lock (relevantVariable)
                    {
                    doStuffEveryInterval();
                    }
                await Task.Delay(interval, cancellationToken);
                }
            }

并且警告是这样的:"因为没有等待这个调用,所以当前方法的执行在调用完成之前继续.考虑将'await'运算符应用于调用的结果.当前方法调用异步方法返回一个任务或任务并不将await运算符应用于结果.对异步方法的调用启动异步任务.但是,由于没有应用await运算符,程序会继续,而不会等待任务完成.在大多数情况下,这种行为不是你所期望的.通常调用方法的其他方面取决于调用的结果,或者最少,在从包含调用的方法返回之前,调用的方法应该完成.

同样重要的问题是在被调用的异步方法中引发的异常会发生什么.在返回任务或任务的方法中引发的异常存储在返回的任务中.如果您未等待任务或显式检查异常,则会丢失异常.如果等待该任务,则重新抛出异常.

作为最佳实践,您应该始终等待通话.

只有当您确定不想等待异步调用完成并且被调用的方法不会引发任何异常时,才应考虑禁止警告.在这种情况下,您可以通过将调用的任务结果分配给变量来抑制警告."

请考虑以下代码:

new Promise(function (res, rej) {
    res('a','b')
}).then(function (a, b) {
    console.log(a,b)
})

它输出

a undefined

如何解决从Promise中返回两个值？

如何在等待状态下运行 Array.map？

const CLASS_PATH = 'User/matt/Github/project';
const PACKAGE_JSON = 'package.json';

const walk = async path => {
  let dirs = [];
  for (const file of await readdir(path)) {
    if ((await stat(join(path, file))).isDirectory()) {
      dirs = [
        ...dirs,
        file,
      ];
    }
  }
  return dirs;
};


async function main() {
  const packagePaths = await walk(CLASS_PATH)
        .map(pkgName => join(CLASS_PATH, pkgName, PACKAGE_JSON));

}
main();

我有一个关于异步编程的问题：

带任务的异步代码（不带异步/等待）和带异步/等待的异步代码有什么区别？

在C#中，我们可以使用Task来编写异步代码或方法，也可以使用关键字。

带任务的异步代码（无异步/等待）

static Task DoWorkAsync()
{
    var work = Task.Run(() => { Thread.Sleep(5000); });
    var workcompleted = work.ContinueWith((x) => { Console.WriteLine("Work Completed!!!"); });
    return work;
}

带有 Async/Await 的异步代码

    static async Task DoWorkAsync()
    {
        await Task.Run(() => { Thread.Sleep(10000); });
        Console.WriteLine("Work Completed");
    }

如果能回答我的问题，我真的很感激。

我试图在查询完成后强制终止（而不是关闭）aq 会话，以节省计算机上的资源。

目前它正在使用：

conn.sendAsync("exit 0")

问题是，如果我在它之后再次运行查询（尝试重新打开连接并运行另一个查询），它可能会失败，因为之前的连接仍会被终止asynchronous。

因此，我尝试对synchronous查询执行相同的操作，但在尝试时：

conn.sendSync("exit 0")

我得到：

ConnectionResetError: [WinError 10054] An existing connection was forcibly closed by the remote host
python-BaseException

我可以指定一个超时，以便 q 会话在 10 秒后自动终止，或者也许还有另一种方法来强制终止 q 会话？

我的代码如下所示：

conn = qc.QConnection(host='localhost', port=12345, timeout=10000)
conn.open()
res = None
try:
    res = conn.sendSync(query, numpy_temporals=True)
except Exception as e:
    print(f'Error running {query}: {e}')
conn.sendSync("exit 0")
conn.close()

我想运行一系列流，其中多个流进程同时运行。我尝试的测试代码如下：

use tokio;
use tokio_stream::{self as stream, StreamExt};
use std::time::Duration;

#[tokio::main]
async fn main() {
    let stream = stream::iter(0..10)
        .then(|i| async move {
            tokio::time::sleep(Duration::from_secs(1)).await;
            println!("i={:?}", i);
        })
        .chunks_timeout(3, Duration::from_secs(20));

    let _result : Vec<_> = stream
        .collect().await;
}

此代码运行，但它会一一打印 10 个值，并有 1 秒的延迟。这与并发相反。我期望的是等待 3 秒，打印 3 个数字，然后等待 1 秒，依此类推。我认为这tokio::time::sleep很好，因为join_all我让代码同时工作。

那么，如何解释缺乏并发性以及如何解决呢？