相关疑难解决方法(0)

我试图在我的程序中加快速度,并且我被告知Ruby Fibers比线程更快并且可以利用多个核心.我环顾四周,但我找不到如何实际同时运行不同的纤维.使用线程,您可以执行此操作:

threads = []

threads << Thread.new {Do something}
threads << Thread.new {Do something}

threads.each {|thread| thread.join}

我看不出如何用纤维做这样的事情.所有我能找到的是yield和resume这似乎是只是一堆开始与纤维之间停止.有没有办法用光纤实现真正的并发？

在像C#这样的语言中,给出这个代码(我没有await故意使用关键字):

async Task Foo()
{
    var task = LongRunningOperationAsync();

    // Some other non-related operation
    AnotherOperation();

    result = task.Result;
}

在第一行中,long操作在另一个线程中运行,并Task返回a(即未来).然后,您可以执行另一个与第一个并行运行的操作,最后,您可以等待操作完成.我认为,这也是行为async/ await在Python,JavaScript等

另一方面,在Rust中,我在RFC中读到:

Rust的期货与其他语言的期货之间的根本区别在于,除非进行调查,否则Rust的期货不会做任何事情.整个系统是围绕这个建立的:例如,取消正在降低未来正是出于这个原因.相比之下,在其他语言中,调用异步fn会旋转一个立即开始执行的未来.

在这种情况下,是什么目的async/ await鲁斯特？看到其他语言,这种表示法是一种运行并行操作的便捷方式,但是如果调用async函数没有运行任何东西,我无法看到它在Rust中是如何工作的.

在JLS的第17章中,它引入了一个概念:发生在一致之前.

如果对于A中的所有读取r,其中W(r)是r看到的写入动作,那么一组动作A发生 - 在一致之前,不是hb(r,W(r))或那里的情况在A中存在写w,使得wv = rv和hb(W(r),w)和hb(w,r)"

在我的理解中,它等于以下几个词:...,既不是......也不是......

所以我的前两个问题是:

• 我的理解对吗？
• "wv = rv"是什么意思？

它还给出了一个例子:17.4.5-1

Thread 1 Thread 2

B = 1; A = 2; 

r2 = A; r1 = B; 

在第一个执行顺序中:

1: B = 1;

3: A = 2;

2: r2 = A;  // sees initial write of 0

4: r1 = B;  // sees initial write of 0

订单本身已经告诉我们两个线程交替执行,所以我的第三个问题是:左数是什么意思？

在我的理解中,r2和r1的原因可以看出0的初始写入是A和B都不是volatile字段.所以我的第四个问题是:我的理解是否正确？

在第二个执行顺序中:

1: r2 = A;  // sees write of A = 2

3: r1 = B;  // sees …

在ac #project项目中,我正在调用一个web api,问题是我在一个方法的循环中做它们.通常没有那么多,但即使我正在考虑利用并行性.

到目前为止我正在尝试的是

public void DeployView(int itemId, string itemCode, int environmentTypeId)
{
    using (var client = new HttpClient())
    {
        client.BaseAddress = new Uri(ConfigurationManager.AppSettings["ApiUrl"]);
        client.DefaultRequestHeaders.Accept.Clear();
        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

        var agents = _agentRepository.GetAgentsByitemId(itemId);

        var tasks = agents.Select(async a =>
            {
                var viewPostRequest = new
                    {
                        AgentId = a.AgentId,
                        itemCode = itemCode,
                        EnvironmentId = environmentTypeId
                    };

                var response = await client.PostAsJsonAsync("api/postView", viewPostRequest);
            });

        Task.WhenAll(tasks);
    }
}

但是想知道这是否是正确的路径,或者我应该尝试并行整个DeployView(即使在使用HttpClient之前)

现在我看到它发布了,我认为我不能只删除变量响应,只需执行等待而不将其设置为任何变量

谢谢

我想组合多个IO应该并行独立运行的值.

val io1: IO[Int] = ???
val io2: IO[Int] = ???

在我看来,我必须选择:

1. 使用带有叉形连接图案的cats-effect纤维

   val parallelSum1: IO[Int] = for {
     fiber1 <- io1.start
     fiber2 <- io2.start
     i1 <- fiber1.join
     i2 <- fiber2.join
   } yield i1 + i2
   

   Run Code Online (Sandbox Code Playgroud)
2. 使用Parallel实例IO与parMapN(或它的兄弟姐妹等中的一种parTraverse,parSequence,parTupled等)

   val parallelSum2: IO[Int] = (io1, io2).parMapN(_ + _)
   

   Run Code Online (Sandbox Code Playgroud)

不确定每种方法的优缺点,何时我应该选择其中一种方法.当抽象出效果类型IO(无标签 - 最终样式)时,这变得更加棘手:

def io1[F[_]]: F[Int] = ???
def io2[F[_]]: F[Int] = ???

def parallelSum1[F[_]: Concurrent]: F[Int] = for …

我正在使用并发.futures 模块来进行多处理和多线程处理。我在具有 16GB RAM、英特尔 i7 第八代处理器的 8 核机器上运行它。我在 Python 3.7.2 甚至 Python 3.8.2 上尝试过这个

import concurrent.futures
import time

def double_value(x):
  y = []
  for elem in x:
    y.append(2 *elem)
  return y

def double_single_value(x):
  return 2* x

import numpy as np
a = np.arange(100000000).reshape(100, 1000000)

 def get_double_value(x):
  with concurrent.futures.ThreadPoolExecutor() as executor:
    results = executor.map(double_single_value, x)
  return list(results)

下面显示的代码运行时间为 115 秒。这仅使用多处理。这段代码的CPU利用率是100%

t = time.time()

with concurrent.futures.ProcessPoolExecutor() as executor:
  my_results = …

现代编程语言为其用户提供并行和并发机制作为一等公民.我理解并行算法是如何编程的,可以很好地想象多核CPU上的两个线程如何并行运行.

但是,大多数这些平台还支持在单个线程上运行并行进程.

• 这些过程是否真的并行运行？
• 如何在汇编级别上在单个线程上同时执行两个不同的例程？

我经常碰到“线程安全”这两个关键术语，想知道这意味着什么。例如，在Firebase或Realm中，某些对象被视为“线程安全”。线程安全的东西到底意味着什么？

我是C#中异步方法的新手.我已经读过这些关键字async并await通过异步某些方法帮助使程序更具响应性.我有这个片段:

第一道路

    public static void Main()
    {
        Console.WriteLine("Hello!! welcome to task application");
        Console.ReadKey();
        Task<string> ourtask = Task.Factory.StartNew<string>(() =>
        {
            return "Good Job";
        });
        ourtask.Wait();
        Console.WriteLine(ourtask.Result);
        Console.ReadKey();
    }

第二种方式

 public static void Main()
        {
            Launch();
        }
        public static async void Launch()
        {
            Console.WriteLine("Hello!! welcome to task application");
            Console.ReadKey();
            Console.WriteLine(await GetMessage());
            Console.ReadKey();
        }

        public static Task<string> GetMessage()
        {
            return Task.Factory.StartNew<string>(() =>
                {
                    return "Good Job";
                });
        }

我需要知道 :

1. 这两种实现之间是否有区别(在并行性的概念中)？

2. 如果我可以创建任务并等待它完成,那么使用async和await关键字有什么好处？

我有一个4核CPU，我创建了一个CPU资源限制为100m的Kubernetes Pod，这意味着它将占用1/10的核心功率。

我想知道在这种情况下100m甚至不是一个完整的内核，如果我的应用程序是多线程应用程序，我的应用程序的线程会并行运行吗？还是所有线程仅在内核（100毫安内核）的一部分中运行？

谁能进一步解释其背后的机制？