标签: pool

我正在尝试实现一些管理资源池的东西，以便调用代码可以请求一个对象，并且如果可用，将从池中获取一个对象，否则将使其等待。但是，我无法使同步正常工作。我的池类中的内容是这样的（其中初始autoEvent设置AutoResetEvent为信号：

public Foo GetFooFromPool()
{
    autoEvent.WaitOne();
    var foo = Pool.FirstOrDefault(p => !p.InUse);
    if (foo != null)
    {
        foo.InUse = true;
        autoEvent.Set();
        return foo;
    }
    else if (Pool.Count < Capacity)
    {
        System.Diagnostics.Debug.WriteLine("count {0}\t capacity {1}", Pool.Count, Capacity);
        foo = new Foo() { InUse = true };
        Pool.Add(foo);
        autoEvent.Set();
        return foo;
    }
    else
    {
        return GetFooFromPool();
    }
}

public void ReleaseFoo(Foo p)
{
    p.InUse = false;
    autoEvent.Set();
}

这个想法是，当您调用 时GetFooFromPool，您会等到收到信号，然后尝试查找Foo未使用的现有对象。如果您找到一个，我们将其设置为InUse，然后发出一个信号，以便其他线程可以继续进行。如果找不到，我们会检查池是否已满。如果没有，我们创建一个新的Foo，将其添加到池中并再次发出信号。如果这两个条件都不满足，我们将再次致电等待 …

我是 python 的新手，我有一个函数可以计算我的数据的特征，然后返回一个应该处理并写入文件的列表。，我正在使用 Pool 进行计算，然后使用回调函数来写入文件，但是没有调用回调函数，我已经在其中放入了一些打印语句，但它肯定没有被调用。我的代码是这样的：

def write_arrow_format(results):
print("writer called")
results[1].to_csv("../data/model_data/feature-"+results[2],sep='\t',encoding='utf-8')
with open('../data/model_data/arow-'+results[2],'w') as f:
     for dic in results[0]:
         feature_list=[]
         print(dic)
         beginLine=True
         for key,value in dic.items():
              if(beginLine):
                feature_list.append(str(value))
                beginLine=False
              else:
                feature_list.append(str(key)+":"+str(value))
         feature_line=" ".join(feature_list)
         f.write(feature_line+"\n")


def generate_features(users,impressions,interactions,items,filename):
    #some processing 
    return [result1,result2,filename]





if __name__=="__main__":
   pool=mp.Pool(mp.cpu_count()-1)

   for i in range(interval):
       if i==interval:
          pool.apply_async(generate_features,(users[begin:],impressions,interactions,items,str(i)),callback=write_arrow_format)
       else:
           pool.apply_async(generate_features,(users[begin:begin+interval],impressions,interactions,items,str(i)),callback=write_arrow_format)
           begin=begin+interval
   pool.close()
   pool.join()

我正在使用多处理pool.starmap功能。我发现一个奇怪的问题。

from multiprocessing import Pool
p = multiprocessing.Pool()

NODE = [1,2,3,4];
PageRank = [0.25,0.25,0.25,0.25];
Destination = [[2,3,4],[3,4],[1,4],[2]];

Data = zip(NODE,PageRank,Destination)

所以我使用zip函数创建一个数据集Data，它是一个列表，每个条目都是长度为 3 的元组。然后我调用该函数

p.starmap(MyFunction, zip(NODE,PageRank,Destination))

效果很好。

但是，当我输入

p.starmap(MyFunction, Data))

它输出空列表[]！！！我真的不知道发生了什么事。我实际上只是替换zip(NODE,PageRank,Destination)为Data，这应该是同一件事，对吧？

是因为我使用 Jupyter 笔记本导致这个问题吗？

有没有人知道用于快速,多线程下载可以通过http代理操作的URL的最有效的包,而不仅仅是使用urllib？我知道一些如Twisted,Scrapy,libcurl等,但我不知道他们做出决定,或者即使他们可以使用代理......任何人都知道最适合我的目的？谢谢!

我试图在我的班级中声明一个内存池.

但是编译器在''之前显示了一些基本的错误,比如''''

或语法错误:'sizeof'

如果我将池用作局部变量,它的效果很好,但我真的想让它与该类一起使用.

我的用法有什么问题？

这是类,MAX_OBJ是const

class CData
{
public:
 CData(void);
 ~CData(void);
private:
 boost::pool m_Pool(sizeof(DWORD) * MAX_OBJ);
};

我正在使用ThreadPoolExecutor来创建处理请求的线程变得容易,但现在要求是按顺序执行请求.我想知道我是否可以使用join方法在上一个启动的线程完成后立即执行一个线程.

我一直在看api,但我还没有找到一个从ThreadPoolExecutor返回Thread对象的方法

我能这样做吗？或者我需要实现像我自己的线程工厂这样的东西吗？

如何在Java中实现连接池？

有一些模式？

我应该使用一些连接并释放它.此连接应在几次后关闭.

在阅读了Java String Pool之后,我决定进行一些测试.我编写了以下测试程序,根据JDK规范,它的结果与Java String Pool行为不匹配.

public class Temp_20141220 {

    private String b1 = "hello";

    public static void main(String[] args) {
        Temp_20141220 t = new Temp_20141220();
        String b = "hello";
        System.out.println("b==b1 =" + t.b1 == b);
    }
}

我一直期望得到输出:b == b1 = true但是我得到了:b == b1 = false

为什么这样？Ubuntu的JVM不支持这个Java字符串池功能吗？

我在池中使用多处理。我需要将结构作为参数传递给必须在单独的进程中使用的函数。我无法使用的映射功能multiprocessing.Pool，因为我无法复制Pool.Queue，也不能复制Pool.Array。该结构将在运行中用于记录每个终止过程的结果。这是我的代码：

import multiprocessing
from multiprocessing import Process, Manager, Queue, Array
import itertools
import time

def do_work(number, out_queue=None):
    if out_queue is not None:
        print "Treated nb ", number
        out_queue.append("Treated nb " + str(number))
    return 0


def multi_run_wrapper(iter_values):
    return do_work(*iter_values)

def test_pool():
    # Get the max cpu
    nb_proc = multiprocessing.cpu_count()

    pool = multiprocessing.Pool(processes=nb_proc)
    total_tasks = 16
    tasks = range(total_tasks)

    out_queue= Queue()  # Use it instead of out_array and change out_queue.append() into out_queue.put() in the do_work() function. …

我试图了解池和队列如何在Python中工作，并且以下示例未按预期工作。我希望程序结束，但是由于第二个队列没有清空，它陷入了无限循环。

import multiprocessing
import os
import time

inq = multiprocessing.Queue()
outq = multiprocessing.Queue()

def worker_main(q1, q2):
    while True:
        i = q1.get(True)
        time.sleep(.1) 
        q2.put(i*2)

def worker2(q):
    print q.get(True)

p1 = multiprocessing.Pool(3, worker_main,(inq, outq,))
p2 = multiprocessing.Pool(2, worker2,(outq,))


for i in range(50):
    inq.put(i)


while inq.qsize()>0 or outq.qsize()>0:
    print 'q1 size', inq.qsize(), 'q2 size', outq.qsize()
    time.sleep(.1)

输出显示第二个队列（outq）为.get一次，仅此而已。

输出：

q1 size 49 q2 size 0
q1 size 47 q2 size 0
2
4
q1 size 44 q2 size 1
q1 size 41 q2 size …

Run Code Online (Sandbox Code Playgroud)