标签: coroutine

我刚刚开始使用协同程序,并阅读了gevent和greenlets.对于测试,我通过gevents pywsgi模块提供了此代码:

from gevent.pywsgi import WSGIServer
import gevent

def hello_world(env, start_response):
    gevent.sleep(5)
    start_response('200 OK', [('Content-Type', 'text/html')])
    return ["<b>hello world</b>"]

print 'Serving on 8088...'
WSGIServer(('127.0.0.1', 8888), hello_world).serve_forever()

我期望一个结果,每个请求在显示文本之前会有5秒的延迟.然而,发生的是每个请求都通过调用gevent.sleep()排队等候,如果第二个请求在第一个请求之后立即启动,则会使第二个请求花费大约10秒.

serve_forever函数不是为每个请求生成新的greenlets吗？

我正在寻找一种方法来添加到Javascript非常特殊的非抢占式多线程形式.Mozilla的Javascript 1.7支持使用本机协同程序yield,但我不想使用特定于浏览器的解决方案.我看到有几个continuation或coroutines的实现,基于将带注释的Javascript代码转换为普通的Javascript.一些例子是StratifiedJS,Narrative Javascript和jwacs.

我不需要一个功能齐全的模拟Javascript异步调用框架; 我只是需要它来实现我想要实现的非常具体的用法.因此,上面的库对我来说太过分了.

有人能指出这种预处理器使用的基本"技巧"(或技巧)吗？是否有一些特殊的语言破解可以在Javascript中实现延续,代价是生成一些额外的代码？欢迎任何相关的参考.

我正在将一个 C++ 项目移植到 iOS，以便在 iPhone 和 iPad 上使用。该项目广泛使用 Boost.Coroutine 库。Boost.Coroutine 没有针对 iPhone 的 ARMv6/ARMv7 指令集的实现。

• 是否有其他可以在 iOS 上运行的协程库？

• 如果没有，是否可以在 ARM 上编写协程行为？我可以看到一些可能的方法来做到这一点：

  • 直接编写汇编指令来执行堆栈操作。我不太精通汇编，我担心 ARM 架构可能不包含复制和粘贴堆栈或手动移动堆栈指针所需的指令。
  • 使用类似于 pthread 或 Win32 纤维的东西编写协程。我不确定是否有类似的东西可以在 iOS 上使用。
  • 在线程之上实现协程，甚至可能是 Boost.Coroutine 本身。这似乎最有可能奏效，但肯定会有性能缺陷。

注意：Unity 在 iOS 上支持 C# 中的协程；我不确定这是否仅限于典型协程行为的较小子集。如果没有，这是否意味着 Unity 有解决方案？

我一直在使用 Python 协程而不是线程，并取得了一些成功。我突然想到我可能会用到一个知道自己的协程，所以它可以给自己发送一些东西。我发现这是不可能的（无论如何在 Python 3.3.3 中）。为了测试，我写了以下代码：

def recursive_coroutine():
    rc = (yield)
    rc.send(rc)

reco = recursive_coroutine()
next(reco)
reco.send(reco)

这引发了一个异常：

Traceback (most recent call last):
  File "rc.py", line 7, in <module>
    reco.send(reco)
  File "rc.py", line 3, in recursive_coroutine
    rc.send(rc)
ValueError: generator already executing

虽然错误很明显，但感觉这应该是可能的。我从来没有想出一个有用的、现实的递归协程应用程序，所以我不是在寻找特定问题的答案。除了实施困难之外，是否还有其他原因无法实现？

我正在通过这个视频教程学习lua ,它有这段代码:

co = coroutine.create(function()
    for i=1,5 do
      print(coroutine.yield(i))
    end
  end)

print(coroutine.resume(co,1,2))
print(coroutine.resume(co,3,4))
print(coroutine.resume(co,5,6))
print(coroutine.resume(co,7,8))
print(coroutine.resume(co,9,10))
print(coroutine.resume(co,11,12))

输出是这样的:

true    1
3   4
true    2
5   6
true    3
7   8
true    4
9   10
true    5
11  12
true

但是我不明白收益和恢复如何将参数传递给对方以及为什么收益率不输出恢复传递给它的前1,2,有人可以解释一下吗？谢谢

我是coroutine和Kotlin的新学徒.为什么我会得到不同的结果,下面的情况1和2？

fun main(args: Array<String>) = runBlocking {
    fun a() = async(CommonPool) {
        println("start A")
        delay(1000)
        println("finish A")
    }

    fun b() = async(CommonPool) {
        println("start B")
        delay(1000)
        println("finish B")
    }

    //case 1
    a().await()
    b().await()

    //case 2
    val A = a()
    val B = b()
    A.await()
    B.await()
}

这种val样式编码是基本的吗？

以下Python协程代码段的Kotlin惯用替代品是什么：

def generator():
  c = 1
  while True:
    op = yield c
    if op == 'inc':
      c += 1
    elif op == 'mult':
      c *= 2

# main
g = generator()
a = g.send(None) # start
b = g.send('inc')
c = g.send('mult')
d = g.send('inc')

print([a, b, c, d]) # 1, 2, 4, 5

因此，我需要从协程中获取值（通过通道？），还需要将这些值发送回协程中。我需要两个渠道吗？

我必须编写一个可以遍历嵌套表的迭代器.我写了一个使用coroutine.

它创建了一个(路径,值)对的数组,例如{{key1, key2, key3}, value}意味着要让value你去做nested_table[key1][key2][key3].

当我写find(),findall(),in()轻松,生活是光明的.

function table.extend(tbl, new_value)
  local tbl = {table.unpack(tbl)}
  table.insert(tbl, new_value)
  return tbl
end

function iterate(tbl, parent)
  local parent = parent or {}
  if (type(tbl)=="table") then
    for key, value in pairs(tbl) do
      iterate(value, table.extend(parent, key))
    end
  end
  coroutine.yield(parent, tbl)
end

function traverse(root)
   return coroutine.wrap(iterate), root
end

然后我意识到我必须使用的Lua环境已coroutine被列入黑名单.我们不能使用它.所以我尝试没有相同的功能coroutine.

-- testdata

local pool = {}
test = {
  ['a'] = …

一旦所有HTTP请求返回，我想启动大量HTTP请求并收集其结果。使用可以以非阻塞方式发送请求asyncio，但是我在收集其结果时遇到问题。

我知道针对此特定问题而设计的解决方案，例如aiohttp。但是HTTP请求只是一个例子，我的问题是如何asyncio正确使用。

在服务器端，我有flask可以localhost/用“ Hello World！” 回答每个请求，但是要等待0.1秒再回答。在所有示例中，我正在发送10个请求。同步代码大约需要1秒钟，异步版本则可以在0.1秒内完成。

在客户端，我想同时启动许多请求并收集其结果。我正在尝试以三种不同的方式来做到这一点。由于asyncio需要执行者来解决阻塞代码，因此所有方法都调用loop.run_in_executor。

这些代码在它们之间共享：

import requests
from time import perf_counter
import asyncio

loop = asyncio.get_event_loop()

async def request_async():
    r = requests.get("http://127.0.0.1:5000/")
    return r.text

def request_sync():
    r = requests.get("http://127.0.0.1:5000/")
    return r.text

方法1：

asyncio.gather()在任务列表中使用，然后单击run_until_complete。阅读Asyncio.gather与asyncio.wait之后，似乎collect会等待结果。但事实并非如此。因此，此代码立即返回，而无需等待请求完成。如果我在此处使用阻止功能，则可以正常工作。为什么我不能使用异步功能？

# approach 1
start = perf_counter()
tasks = []
for i in range(10):
    tasks.append(loop.run_in_executor(None, request_async)) # <---- using async function !

gathered_tasks = asyncio.gather(*tasks)
results = loop.run_until_complete(gathered_tasks) …

首次使用协程。需要帮忙。

这是我的流程：

演示者要登录，因此调用存储库接口。仓库实现RepositoryInterface。因此，存储库调用APIInterface。APIInterface由APIInterfaceImpl实现。APIInterfaceImpl最终调用MyRetrofitInterface。

这是图解的流程图：

演示者->存储库-> APIInterfaceImpl-> MyRetrofitInterface

获得登录响应后：

APIInterfaceImpl->存储库->将数据存储在缓存中->将HTTP状态代码提供给Presenter

这是我的代码：

RepositoryInterface.kt

fun onUserLogin(loginRequest: LoginRequest): LoginResponse

仓库

class Repository : RepositoryInterface {
   private var apiInterface: APIInterface? = null

   override fun onUserLogin(loginRequest: LoginRequest): LoginResponse {
         return apiInterface?.makeLoginCall(loginRequest)
   }
}

APIInterface.kt

suspend fun makeLoginCall(loginRequest): LoginResponse?

APIInterfaceImpl.kt

override suspend fun makeLoginCall(loginRequest: LoginRequest): LoginResponse? {
        if (isInternetPresent(context)) {
            try {
                val response = MyRetrofitInterface?.loginRequest(loginRequest)?.await()
                return response
            } catch (e: Exception) {
                //How do i return a status code here
            }
        } else {
        //How do …