我学习了一门操作系统课程，在这门课程中，我们学习了常见的并发问题，如：用餐哲学家问题、生产者-消费者问题、读者和作者问题 既然它们的主要目的是保护共享变量，那么在Erlang中解决这些问题有意义吗？或者我只是需要更多的Erlang培训来找出解决方案 谢谢我理解这个问题，但这些问题与锁定和互斥有关 Erlang通过Actors进行操作的方式避免了锁定问题。在Erlang中创建生产者、消费者、读者和作者是一件好事，但就解决互斥问题而言，您将使用消息而不是共享变量 在Erlang中，您“不共享任何内容

我正在详细阐述一个对我来说似乎很难的问题，我不希望有一个简单的解决方案，但也许有一些行之有效的实践或进一步的阅读可以让这变得更容易。我敢肯定，在许多应用程序（例如垃圾收集或事务数据库）中都会出现一般性问题 我的应用程序有一个由多个线程同时遍历的图（如果有关系的话是DAG）。其中一些只是试图找到某些节点或检索子图，其他的可能会改变图的结构 我想要实现的策略是，读取线程将在图形的“快照”上执行其整个操作，即。E查看某个时间点的结构 我目前的计划是在事务性数据库中设置类似于行版本控制的东西，即。E读取

如果你可以肯定地证明一个方法没有线性化点，那么这是否一定意味着该方法是不可线性化的？另外，作为一个子问题，你如何证明一个方法没有线性化点？这个答案是基于我第一次在维基百科上阅读关于线性化的内容，并试图通过“先发生后关系”将其映射到我对内存一致性的现有理解。所以我可能误解了这个概念 如果你能肯定地证明一个方法没有线性化点，你会这样做吗 这必然意味着该方法不可线性化 在这种情况下，共享的可变状态可以由多个线程并发操作，而无需任何同步或可见性辅助，并且仍然可以维护所有不变量，而不会有损坏的风险 然而，

我为OpenCL编写了一个内核，其中我将3D数组的所有元素初始化为->I*I*I+j*j*j。我现在在创建线程网格来初始化元素（同时）时遇到了问题。我知道我现在的代码只使用了3个线程，我如何扩展它呢 请帮忙。我是OpenCL的新手，所以任何建议或解释都很方便。谢谢 这是代码： _kernel void initialize ( int X; int Y; int Z; _global float*A) { // Get global position in X direction int di

我很好奇围棋语言是如何安排goroutines的。它是否仅在通道请求和I/O期间切换，还是具有周期性的协同路由切换循环？Go还没有抢占式调度程序，但有一个是。因此，不，Go在仅CPU计算期间，仅在I/O期间，不会切换上下文（如果从内存读取的内容还不在寄存器中，则也将其视为I/O）。您可以在中阅读一些关于它的讨论。如果我理解正确，将这些链接中描述的内容称为“抢占式调度”太牵强了。这并不是真正的先发制人，只是在程序员看不见的情况下，收益率被放在了更多的地方。当然，这使程序更“并发”，但它仍然是协作的

当然有，但它没有承诺/未来组合的功能（没有等价物来获得未来或设置结果或异常，你也不能等待完成）。我相信你没有认真考虑std.parallelism。。。与“获取未来”（如果您指的是std:：future的get（）方法）等效的是yieldForce（）、spinForce（）和forforce（）。仔细阅读这些，你会发现你也可以等待完成 std:：future:：get（）等待future获得有效结果并（取决于使用的模板）检索该结果。这正是yieldForce所做的 关于例外。。。你在哪里看到你

我在erlang中创建了一轮进程，并希望测量第一条消息通过网络和整个消息系列所花费的时间，每次第一个节点返回消息时，它都会发送另一条消息。 现在在第一个节点中，我有以下代码： receive stop-> io:format("all processes stopped!~n"), true; start-> statistics(runtime), Son!{number, 1}, msg(PID, Son, M, 1); {_, M

我搜索了Swift书籍，但找不到@synchronized的Swift版本。如何在Swift中实现互斥？您可以在objc\u sync\u enter（obj:AnyObject？和objc\u sync\u exit（obj:AnyObject？）之间夹杂语句。@synchronized关键字在幕后使用这些方法。i、 e objc_sync_enter(self) ... synchronized code ... objc_sync_exit(self) 你可以使用GCD。它比@synch

我读过关于GFS及其一致性模型的书，但我没能理解其中的一些内容。 特别是，有人能为我提供一个具体的示例场景（或解释为什么它不能发生）： 可能导致记录重复的并发记录追加 可能导致未定义区域的并发记录追加 可能导致未定义区域的并发写入（在单个块上） 我认为这与并发追加无关，但至少与系统的一次语义有关 故障是大型分布式系统的一个基本问题。出现故障时，发送方可能不知道网络另一端的计算机是否完全接收到其消息 在这种情况下，分布式系统保证消息最多传递一次或至少传递一次 在这种情况下，GFS似乎决定至少向存

几个小时后，我被c++11的unique\u lock的意外行为狠狠地打了一顿。我一定是严重误解了什么： #include <iostream> #include <vector> #include <thread> #include <mutex> #define N_THREADS 4 #define N_ITERATIONS 10000 #define N_LOOPS 1000000 class ThingMaJigger { publi

大家好，堆栈溢出 我有一个关于2PL和死锁功能的问题。我不知道为什么这对我来说很难理解，但我已经尝试制作一个伪序列图来简化理解 我对2PL的理解在这里正确吗？我知道死锁处理并不特定于2PL 是否正确理解为，如果T1事务已获得写锁（独占），T2然后尝试获得读锁，则T2将被迫等待 我知道只有一个事务可以有写锁，但正如我所理解的2PL，如果一个事务正在修改（具有写锁），那么另一个事务就无法读取（获取读锁） 期待您的回答-祝您周末愉快。：-） /本

我对同步有一个普遍的怀疑-> 当我们说两个过程之间的互斥满足时，我的意思是这是理想的性质。这不是一个需要解决的问题 同样，死锁、竞争条件也是需要解决的问题 因此，同步也是一个需要维护的属性，也就是说，“它是需要的东西”还是“需要解决的问题”需要的属性是 线程安全，或保护某些数据结构的完整性，防止同时进行的更改损坏该数据结构的内容，以及 活跃度，即线程取得进展的能力 同步是一种在不影响活动性的情况下保持共享数据完整性的方法。这只是众多旨在保护线程安全性的技术之一 如果出现死锁，或者出现瓶颈（如

请参阅文章标题：“读者-作者问题”是否只是多个消费者的“生产者-消费者问题”？直觉上我会说不，但我没有办法解释它，也可以看到这个问题得到肯定 读写器意味着读写器不修改底层状态，因此许多读写器可以同时访问底层状态；但是，由于写入程序可以自由修改状态，因此没有读取器可以同时访问它 生产者-消费者是两个访问器的常见同步问题：一个用于补充资源，另一个用于消耗资源。您不能让多个生产者或消费者同时访问它。这种混乱可能会出现，因为有许多（受限的）实现使用忙等待（呃，事务内存）来从这种模式中获得更好的性能。生产

DynamoDB新手，对学习NoSQL数据库感兴趣 我有一个场景，其中我有一个表，它有一个userId分区键、一个time排序键和一个数字句柄。句柄是按1递增的顺序计数器 以下是该表的一个示例： userId, time, handle 0 , 123 , 1 0 , 456 , 2 1 , 123 , 1 1 , 234 , 2 0 , 789 , 3 1 , 345 , 3 对于给定的userId，句柄不能有重复项 我希望能够为userId

我有许多操作（异步列表）要在F#中执行。我可以并行执行这些操作中的大多数，但有些操作可能会由于文件锁定等原因而发生冲突 对于每个操作，我可以生成一个“键”（int），用于确定操作是否可能冲突： 如果动作a有键i，动作b有键j和i=j，则a和b可能冲突。它们必须连续执行 如果动作a有键i，动作b有键j和ij，则a和b将永远不会冲突。它们可以并行执行 我希望以高效且无冲突的方式执行我的操作（int*Async）list 我想象这个过程会是这样的： 按键对所有操作进行分组 将每个组串行链接成一个

使用命名锁（例如，密钥名称）同步对作用域和结构的特定密钥的读/写访问是否安全？我已经做了一段时间了，从来没有遇到过并发问题，但我正在编写一个服务器级缓存，我想确保基于名称的锁定在服务器范围内是安全的。我担心底层的实现可能不是线程安全的，对不同密钥的并发访问可能会导致问题。ColdFusion中通过cflock实现的锁仅仅是线程安全的。它们控制哪些线程可以同时（并发）访问代码。这些锁不会影响Java的内在锁或同步的方法/语句。因此，cflock本身并不提供线程安全性 用户显示CF结构不使用Conc

我目前正在学习并行软件设计课程，我们非常关注建模。我看到了其中的价值，但我不确定我们使用的工具是可怕的、好的还是介于两者之间，因为我找不到任何其他例子。我们目前正在使用LTS Analyzer，并提供了更多信息 所以我的问题是，对于那些做过并发系统设计的人来说，在实现之前，你们是否对你们的应用程序进行建模，如果是的话，你们用什么工具来实现呢？谢谢。虽然我还没有用过我自己，但我听说了一些关于它的好东西（计划很快使用它）。在不同行业中，对并发/分布式系统进行建模和验证的一个更广为人知的工具是SPIN

如果代码很难理解，我很抱歉。 这是一个经典的哲学家进餐问题，5个哲学家在进餐，但只有5根棍子——你需要两根来吃 如果有人感兴趣，请参阅以下说明： 总之，这是代码，筷子过程代码： -module(chopstick). -export([start/0]). start() -> spawn_link(fun() -> init() end). init() -> available(). available() -> receive {request, Fr

我将任务队列/线程池模式系统与D中的n线程系统进行比较。我对D编程语言非常陌生，但以前曾在C、Java和Python中使用过线程。我正在使用Tango库，并以构建Web服务器为例 我决定使用tango.core.ThreadPool作为我的线程池，因为我的项目主要关注传统线程和任务队列之间的易用性和性能 显示我有3个选项： ThreadPool.wait（）-在线程池使用队列中的任务时阻止当前线程 ThreadPool.shutdown（）-完成池中的任务，但不完成队列中的任务 ThreadPo

我已经完成了围棋之旅，我已经完成了网络爬虫练习，但是我认为我用来打印所有结果的技术可能效率低下 这是我的密码。我只编辑了爬网和主要功能，所以我将发布它。以下是练习（）的链接 因为爬网函数是递归的，所以很难在爬网函数中使用“close（results）”，但按照我的方法，我必须找到每次使用的变量的长度 有更好的方法吗？要等待goroutine集合完成，请使用sync.WaitGroup 我相信你会发现官方文件中的例子非常熟悉 引述： var wg sync.WaitGroup var urls

我正在为我的一个USCASE准备解决方案。 我的解决方案在抽象上可能是这样的 我这里的问题是，当两个主流当前调用相同的子流时， 它能正常工作吗 我还需要为所有用作线程的类编写线程安全的代码吗 子流中的自定义组件/转换器 我的抽象配置如下所示 <flow name="mainflow_1" > <inbound-endpoint/> <transformer ....> <component ....> <

以下是正确的吗 如果必须以多种方式（io操作或注释）处理每个条目，则具有更好的并行性能和可伸缩性，因为可以使用多个使用者并行处理，而不会产生争用 相反，（即本地存储条目并从其他线程窃取条目）如果每个条目只能以单一方式处理，则具有更好的并行性能和可伸缩性，因为在中断器模式中将条目分散到多个线程上会导致争用 （当涉及多个生产者时，破坏者模式是否比其他无锁多生产者多消费者队列（例如）快得多？） 我的详细情况： 处理一个条目会产生几个新条目，这些条目最终也必须被处理。性能具有最高优先级，按FIFO

我需要开始大量的goroutines并等待它们的终止。直观的方法似乎是使用一个通道来等待所有这些操作完成： package main type Object struct { //data } func (obj *Object) Update(channel chan int) { //update data channel <- 1 return } func main() { channel := make(chan int, n)

考虑一下这个计划： package main import "fmt" import "time" import "runtime" func main() { x := 0 go func() { time.Sleep(500 * time.Millisecond) x = 1 }() for x == 0 { runtime.Gosched() } fmt.Println("it wo

以下是我处理序列化的一种方法（并设置了有限数量的工作人员）。我使用输入和输出字段以及同步通道设置了一些worker对象，然后对它们进行循环，提取它们所做的任何工作并给它们一个新的作业。然后我对它们进行最后一次遍历，以提取剩余的任何已完成作业。请注意，您可能希望worker计数稍微超过您的核心计数，因此即使有一个异常长的作业，您也可以让所有资源忙碌一段时间 这很复杂（比我坐下来写一个例子之前记得的要复杂！）——我很想看看其他人有什么，或者是更好的实现，或者是一种完全不同的方式来实现你的目标 fun

了解有关Erlang消息传递行为的时间顺序的这些事实： 如果进程A向进程B发送两条消息，则保证这两条消息按发送顺序到达 如果进程A先向进程B发送一条消息，然后再向进程C发送一条消息，则无法保证接收它们的顺序 同样，如果进程A和B向C发送消息，则无法保证消息的接收顺序 我的问题是: 如果进程A和B向进程C发送消息，当A和B在同一个（微）时间内，在同一个节点上，在可以运行并行进程的同一台机器上，使用相同的内部功能发送消息时，接收顺序是什么 在这种情况下，您也不能对接收订单进行任何假设。接收顺序将取决

我有以下模式： task<Param1^> MyClass::MethodA(String^ s) { return create_task([this, s] { .... IAsyncOperation<Param1^>^ result = SystemMethod1ReturningParam1(...); return result; }); } IAsyncOperati

拥有以下各项之间的区别是什么： 一个并发性为4或4的工作进程 两个工作线程，每个并发2个 对于同一队列 谢谢你提出了一个有趣的问题 我能想到的事情（我相信还有很多）： 对于高可用性： 您需要多台机器（如果一台机器停机），因此必须使用每台机器一个工人 即使对于一台机器，我认为在两个不同的进程中运行两个worker，而不是一个具有高并发性的worker更安全（如果我错了，请纠正我，但我认为它是通过线程实现的） 在我看来，他们建议每个CPU使用并发性 如果您想将不同的任务分配给不同的工作人员 当

在硬件和软件方面，赛车条件的一些实际例子是什么？ 这个例子不应该是关于解释什么是竞争条件的代码，而应该是系统中的一种情况 例如，当两个音乐播放器试图访问扬声器时。您可以通过下面的一个简单示例进行很好的解释： 我将引用最重要的部分（老实说，这几乎是完整的文章） Visual Basic代码： 'Thread 1 Total = Total + val1 'Thread 2 Total = Total - val2 'Thread 1 1. mov e

我有两个进程（不是线程）应该同时读取系统时钟。为此，第一个过程使用 QTime:：currentTime（）只有一种竞争条件，即您无法预测哪个进程将报告更早的时间，或者它们是否将报告相同的时间。同时（几乎）读取时钟不会造成任何伤害。这两份报告将在操作系统提供信息的能力范围内准确无误。根据操作系统和硬件的不同，两个进程可能同时报告，也可能不同时报告 它可能是也可能不是共享资源。它甚至可能不是引擎盖下的同一个时钟std:：chrono:：high_resolution_clock通常是typede

我有一个用Erlang编写的神经网络，我刚买了一个GeForce GTX 260卡，上面有一个240核的GPU。作为胶水在图形卡上运行此功能是否很简单？不，使用CUDA不是一件小事 CUDA编程模型基本上使用C（还有一些附加），但是为了获得GPGPU的大部分功能，您必须确保您的算法遵循CUDA指南。（见附件） 例如，为了获得最佳内存性能（大约70Gbps），您需要在流模式下通过合并访问内存，而且分支在GPU上的成本非常高，因此您应该尽可能避免使用条件。查看SDK提供的指南和示例，它们将提供一个极

嗨，我们尝试实现一个过程，比如当用户做了什么，他的公司的信用将相应扣除 但是，当一家公司中的多个用户由于信用被错误扣除而参与该过程时，会出现并发问题 有人能为这一问题指出正确的方向吗？ 非常感谢 这是一个完全独立于实现语言的经典问题 您有一个维护持久数据存储的共享资源。（这通常是一个数据库，可能是一个RDBMS） 您还有一个（业务）流程，使用和/或修改共享数据存储中维护的信息 当这个过程可以由多个参与者同时执行时，就会出现信息完整性问题 解决此问题的最常见方法是序列化对共享资源的访问，以便对共享

有什么好的来源/链接或简明的解释吗 非常感谢 容器有一个线程池和一个请求队列。当请求传入时，它将被添加到队列中。侦听器将请求从队列中取出，从线程池中检查线程，并将请求交给它处理。进程完成后，线程返回池中等待下一次分配 当线程池耗尽时，请求将备份到队列中，直到有足够的资源来处理它们。容器有一个线程池和一个请求队列。当请求传入时，它将被添加到队列中。侦听器将请求从队列中取出，从线程池中检查线程，并将请求交给它处理。进程完成后，线程返回池中等待下一次分配 当线程池耗尽时，请求将备份到队列中，直到有足够

下面是一个场景：一个查询memcached缓存的简单网站。该缓存每10-15分钟由批处理作业更新一次。使用该模式是否存在任何可能出错的情况（例如缓存未命中） 我担心所有可能发生的比赛情况。例如，如果网站对缓存在memcached中的对象执行GET操作，而该对象被批处理作业覆盖，那么会发生什么情况？我最初的直觉是，您应该能够从memcached缓存中读取/写入数据，而不会产生任何副作用（因为竞争条件可能导致数据过时） 关于memcached的常见问题： memcached是原子的吗？除了你可能遇到

我看到过不同的代码片段演示了一个Put消息，该消息使用F#的MailboxProcessor返回unit。在某些情况下，仅使用Post方法，而其他情况下使用PostAndAsyncReply，回复通道在处理消息后立即回复。在做一些测试时，我发现在等待回复时存在明显的时间延迟，因此，除非您需要真正的回复，否则应该使用Post 注意：我开始问这个问题，但我认为把它作为一个完整的问题发布是有用的。在另一个线程中，Tomas Petricek提到回复通道可以用作等待机制，以确保调用方延迟到处理Put消息

我刚刚尝试了以下代码，但结果似乎有点奇怪。它先打印奇数，然后打印偶数。我真的很困惑。我希望它能一个接一个地输出奇数和偶数，就像1、2、3、4。谁能帮我 package main import ( "fmt" "time" ) func main() { go sheep(1) go sheep(2) time.Sleep(100000) } func sheep(i int) { for ; ; i += 2 { fmt.Pr

我找到了一个关于如何在池中使用的示例。它说我只需要将单词Parallel添加到Groovy的方法中，比如collect、find、each，将其放入withPool，然后它并行执行代码 import static groovyx.gpars.GParsPool.withPool list = 1..1000000 withPool{ squares = list.collectParallel { it * it} } println squares 是否有机会检查它是否真的是平行

我有两种情况： 情形1：有两个线程，它们共享具有doSomething（）方法的类的一个实例。 情形2：有2个线程，每个线程都有一个类的实例，该类具有doSomething（）方法 void doSomething（）{ 对于（int i=0；i

在我的程序中，我有两个内核，每个内核只启动两个256个线程的块 kernel1<<<2,256>>>() kernel2<<<2,256>>>() 我想知道是否有可能在同一个程序中同时启动两个内核，并有这样的东西，将执行时间除以2： SMX1 SMX2 --------- | K1 | K1 | | K1 | K1 | ----------- | K2 | K2 | | K2 | K2 | ---------

RWH手册中规定了以下内容： 如果Chan为空，readChan将阻塞，直到有一个值要读取。 writeChan函数从不阻塞：它将新值写入Chan 马上 我不清楚的是，调用writeChan是否会覆盖已存在的消息（假设某些消息尚未读取），或者它是否会按正确的顺序将消息排队，以便未读消息不会丢失？它会排队Chan是一个通道，消息可以在其中排队。相比之下，MVar可以只取一个值，作为变量而不是队列Chan是一个通道，消息可以在其中排队。相比之下，MVar可以只取一个值，表现为变量而不是队列。我不打算

我有一个关于并行编程的问题。如果我有一个程序作用于数组的每个元素，为什么使用所有可用的处理器不是很有利 我在想，可能是因为设置和管理多个线程的开销很大，或者如果阵列大小不保证并发解决方案的话。还有谁能想到别的吗 我会使该数组成为一个静态变量，根据它的大小，我会划分任务并分配多个踏板来执行数组中每组元素的工作 例如，如果数组中有100个元素。我会把它分成10组。 用10条不同的线我就能完成我的工作 如果我不明白你的意思，请纠正我 编辑：- 操作系统已经为您做到了这一点。它不能保证每个线程永远都在同

我目前正试图编写一个简单的websocket，当有人加入或离开websocket连接池时，它会列出每个连接的客户端的所有客户端列表 目前，我正在使用（R）锁定和解锁来确保存在并发连接，以避免连接之间的任何干扰。 每当我尝试访问连接池时，我都会锁定它，这包括对连接池的读写，但出于某种奇怪的原因，只有当我通过一次发送100个并发连接来强制执行websocket时，我会终止所有连接，我会得到一个断开的管道错误 从外观上看，该错误发生在删除客户端并广播新客户端列表之后 你能找出为什么当有人断开连接时，它

我有一个线程间通信问题的简单示例：我想在后台线程中运行任意“随时”算法。anytime算法以增量方式执行一些结果类型T的计算，也就是说，它偶尔会生成更新、更精确的结果。用Nim的说法，它们可能最好用迭代器来表示。在主线程中，我现在希望将这样的迭代器分别封装在自己的线程中，可以查询线程中的“是否有新值可用”或“当前计算结果是什么” 由于我不熟悉Nim的并发性概念，因此难以实现所需的线程间通信。我的想法是使用t频道进行通信。根据，一个TChannel不能与spawn结合使用，但需要使用createT

我必须创建一个dropwizard的演示文稿，我的教授希望我关注的一些要点是并发处理和dropwizard的性能 我在谷歌上搜索了dropwizard，dropwizard并发，dropwizard如何处理并发，但没有得到任何合适的答案 所以，请帮我解决这个问题。dropwizard的作用是，它所做的只是将标准汇集在一起，然后以一种只需您一点点努力的方式为您将它们连接起来。所以DW本身并没有为您提供并发性和性能，它提供了可以提供并发性和性能的组件 关于您的问题，您需要以不同的方式提问，以便为DW

我有一个要求，我需要40个线程来完成某项任务（合并），大约20个线程来完成另一项任务（持久化）。合并所需的时间大约是持久性的5倍。 我正在使用消息驱动bean来实现这种并发性 我用以下配置创建了一个MDB记录合并 @MessageDriven(activationConfig = { @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"), @A

在Go中分配指针是原子的吗 我需要在锁中指定指针吗？假设我只想将指针指定给nil，并希望其他线程能够看到它。我知道在Java中我们可以使用volatile，但是Go中没有volatile。因为规范没有指定，所以您应该假设它不是。即使它当前是原子的，也有可能在不违反规范的情况下进行更改。保证在go中是原子的唯一东西是在go中的操作 所以，如果你想确定，你要么需要一个锁，例如，或者使用一个原子原语。但是我不建议使用原子原语，因为在使用指针的任何地方都必须使用它们，而且它们很难正确使用 使用互斥是OK

我是Clojure的初学者，我读过它的并发系统，比如atoms、refs和Agent。我似乎找不到文档说明的是，是否可以在不同的系统中包装数据结构以用于不同的功能 假设我将这样表示数据： { :id {:counter 0 :text: ""}, :id2 {:counter 0 :text: ""} } (def myAtom (atom {})) 我想使用atom来更新单个嵌套映射的计数器，因此我定义了如下atom： { :id {:counter 0 :text: ""}, :id

我正在评估RabbitMQ，并希望执行以下操作： 将消息放在一个队列中，该队列的整数属性X的范围为400万 队列中将存在多个具有相同值X的消息 使用多个侦听器读取队列，但确保没有任何侦听器同时处理具有相同值X的消息 RabbitMQ是否可以实现这一点？我应该使用哪种功能 编辑 我们改为具有此功能的ActiveMQ您找到答案了吗？没有。我们可能会自己编写一些东西来解决此问题。没有排队系统能做我们想做的事

同时使用的用户总数-200， 测试持续时间-2小时 荷载剖面图： 脚本1：浏览目录->10个步骤>2000个预期业务流程/小时率>100个用户 脚本2：搜索产品->6个步骤>1400预期业务流程/小时率>60个用户 脚本3：购买产品->12个步骤>600预期业务流程/小时率>40个用户 只有这些数据，如何找出平均用户并发率（每秒）？并发率与给定时间范围内的冲突有关。同时性是关于同样的要求，同样的时间 一小时内的并发性在一秒钟内是不同的。对于您的每个步骤，也不可能了解向测试中的服务器发出了多少请求

我想用scrapy来抓取相当大的网站。在某些情况下，我将已经有链接，以刮，在其他情况下，我将需要提取（爬网）他们。运行时，我还需要访问数据库两次。一次用于确定是否需要删除url（Spider中间件），一次用于存储提取的信息（项目管道）。 理想情况下，我将能够运行并发或分布式爬网，以加快速度。使用scrapy运行并发或分布式爬网的推荐方法是什么 你应该检查一下 实现起来非常简单。您的计划程序和重复过滤器将存储在redis队列中。所有蜘蛛将同时工作，你应该加快你的爬行时间 希望这能有所帮助。文档中列