标签: pool

我正在读取一个二进制文件并希望将字节转换为美国 ASCII 字符串。有没有办法在不调用的new情况String下避免String在字符串文字池中创建多个语义相等的对象？我认为这可能是不可能的，因为String这里不可能使用双引号引入对象。这样对吗？

private String nextString(DataInputStream dis, int size)
throws IOException
{
  byte[] bytesHolder = new byte[size];
  dis.read(bytesHolder);
  return new String(bytesHolder, Charset.forName("US-ASCII")).trim();

我想使用以下代码创建 Oracle UCP：

import oracle.ucp.jdbc.PoolDataSource;
import oracle.ucp.jdbc.PoolDataSourceFactory;

System.out.println("***** OracleDS_UCP -> start init of PoolDataSource");

            PoolDataSource pool = PoolDataSourceFactory.getPoolDataSource();
            pool.setConnectionFactoryClassName("oracle.jdbc.pool.OracleDataSource");
            pool.setURL("jdbc:oracle:thin:@localhost:1521:XE");
            pool.setUser("test");
            pool.setPassword("test");
            pool.setMaxStatements(10); // the maximum number of statements that may be pooled or cached on a connection.
            pool.setInitialPoolSize(2);
            pool.setMinPoolSize(1);
            pool.setMaxPoolSize(50);
            pool.setLoginTimeout(60); // one minute
            pool.setConnectionWaitTimeout(60); // one minute
            pool.setAbandonedConnectionTimeout(30 * 60); // thirty minutes
            pool.setMaxIdleTime(60 * 60); // one hour and kill inactive or idle connections
            pool.setInactiveConnectionTimeout(60 * 60); // one hour and kill inactive or idle connections
            pool.setConnectionWaitTimeout(0); …

我有一个java进程,它启动大约60个线程,每个线程访问一个MySql数据库.

使用像C3P0这样的连接池会有好处吗？或者它仅适用于Web应用程序(可扩展到许多用户)？

今天我们有长期存在的JDBC连接(每个线程一个),我的计划是在每次SQL查询/插入之前从连接池获取连接.

我想知道这是否会使我们的应用程序更稳定？另外,如果我将其配置为匹配数据库中的最大连接数,那么线程是否必须等到有空闲连接？文档不是很清楚(至少不适合我).

任何指导表示赞赏!

https://github.com/xetorthio/jedis/wiki/Getting-started

在多线程环境中使用 Jedis

您不应该使用来自不同线程的相同实例，因为您会遇到奇怪的错误。有时创建大量 Jedis 实例还不够好，因为这意味着大量套接字和连接，这也会导致奇怪的错误。

单个 Jedis 实例不是线程安全的

！为了避免这些问题，您应该使用 JedisPool，它是一个线程安全的网络连接池。您可以使用池来可靠地创建多个 Jedis 实例，前提是您在完成后将 Jedis 实例返回到池中。通过这种方式，您可以克服那些奇怪的错误并获得出色的性能。

==================================================

我想知道为什么？任何人都可以帮助我吗

我有一个使用 Tomcat JDBC 连接池的项目。

根据JDK规范，该Connection.close()方法应该释放连接的资源，如Statement和ResultSet。

我知道当使用池中的连接时，该close()方法将被覆盖以将连接释放回池。我想知道这个覆盖的方法是否应该正确关闭相关资源。

Tomcat JDBC 连接池不释放资源，我需要在我的代码中显式关闭所有资源。

是否有任何其他池实现可以在调用时正确关闭所有相关资源Connection.close()？

我想将文本输入到 python 并并行处理它。为此，我使用multiprocessing.Pool. 问题是有时，并非总是如此，我必须在处理任何内容之前多次输入文本。

这是我重现问题的代码的最小版本：

import multiprocessing as mp
import time

def do_something(text):
    print('Out: ' + text, flush=True)
    # do some awesome stuff here

if __name__ == '__main__':
    p = None
    while True:
        message = input('In: ')
        if not p:
            p = mp.Pool()
        p.apply_async(do_something, (message,))

发生的情况是我必须多次输入文本才能得到结果，无论我在第一次输入内容后等待多久。（如上所述，这不会每次都发生。）

python3 test.py
In: a
In: a
In: a
In: Out: a
Out: a
Out: a

如果我在 while 循环之前创建池，或者如果我time.sleep(1)在创建池之后添加，它似乎每次都有效。注意：我不想在获得输入之前创建池。

有人对这种行为有解释吗？

我正在使用 Python 3.4.2 运行 Windows 10 编辑：与 Python 3.5.1 相同的行为

编辑： …

有一个奇怪的行为，map使用Python的时候multiprocessing.Pool。在下面的示例中，一个由 4 个处理器组成的池将处理 28 个任务。这应该需要七遍，每遍需要 4 秒。

然而，它需要8个pass。在前六轮中，所有处理器都被占用。在第 7 次传递中，仅完成了两个任务（两个空闲处理器）。剩下的 2 个任务在第 8 次传递中完成（再次是两个空闲处理器）。这种行为出现在看似随机的 cpu 数量和任务数量组合中，不必要地浪费时间。

此示例已在 Intel Xeon Haswell（20 核）和 Intel i7（4 核）上重现。

关于如何强制Pool在所有通道中使用所有可用处理器的任何想法？

import time
import multiprocessing
from multiprocessing import Pool
import datetime

def f(values):
    now = str(datetime.datetime.now())
    proc_id = str(multiprocessing.current_process())
    print(proc_id+' '+now)
    a=values**2
    time.sleep(4)
    return a 

if __name__ == '__main__':
    p = Pool(4) #number of processes
    processed_values= p.map( f, range(28))
    p.close()
    p.join()
    print processed_values

运行的输出如下

<Process(PoolWorker-1, started daemon)> 2016-05-13 17:08:49.604065
<Process(PoolWorker-2, …

mac os,python2.7我使用多处理,但它失败了:

In [1]: from multiprocessing import Pool

In [2]: pool = Pool(30)

OSError                                   Traceback (most recent call last)
/Users/mac/Documents/python-f/ga_users_v4_multipro.py in <module>()
    141 
    142 if __name__ == '__main__':
--> 143   a,t=main()
    144 

/Users/mac/Documents/python-f/ga_users_v4_multipro.py in main()
    111     date_range.append(t.strftime('%Y-%m-%d'))
    112 
--> 113   pool = Pool(30)
    114   rrr=pool.map(get_report, date_range)
    115   pool.close()

/Users/mac/.edm/envs/edm/lib/python2.7/multiprocessing/__init__.pyc in Pool(processes, initializer, initargs, maxtasksperchild)
    230     '''
    231     from multiprocessing.pool import Pool
--> 232     return Pool(processes, initializer, initargs, maxtasksperchild)
    233 
    234 def RawValue(typecode_or_type, *args):

/Users/mac/.edm/envs/edm/lib/python2.7/multiprocessing/pool.pyc in __init__(self, processes, initializer, initargs, maxtasksperchild) …

我正在尝试为大型Obj类型实现全局对象池。这是代码POOL：

static mut POOL: Option<Mutex<Vec<Obj>>> = None;
static INIT: Once = ONCE_INIT;

pub struct Obj;

这是我访问和锁定的方式POOL：

fn get_pool<'a>() -> MutexGuard<'a, Vec<Obj>> {
    unsafe {
        match POOL {
            Some(ref mutex) => mutex.lock().unwrap(),
            None            => {
                INIT.call_once(|| {
                    POOL = Some(Mutex::new(vec![]));
                });
                get_pool()
            }
        }
    }
}

这是导致问题的代码：

impl Drop for Obj {
    fn drop(&mut self) {
        println!("dropping.");
        println!("hangs here...");
        get_pool().push(Obj {});
    }
}

impl Obj {
    pub fn new() -> Obj {
        println!("initializing");
        get_pool().pop().unwrap_or(Obj {}) …

问题:
当发送1000个任务到apply_async时,它们在所有48个CPU上并行运行,但是有时运行的CPU越来越少,直到只剩下一个CPU运行,并且只有当最后一个CPU完成其任务时,才会运行所有CPU使用新任务再次继续运行.它不应该等待像这样的任何"任务批处理"..

我的(简化)代码:

from multiprocessing import Pool
pool = Pool(47)
tasks = [pool.apply_async(json2features, (j,)) for j in jsons]
feats = [t.get() for t in tasks]

jsons = [...]是已加载到内存并解析为对象的大约1000个JSON的列表.
json2features(json)在json上做一些CPU繁重的工作,并返回一个数字数组.
此功能可能需要1秒到15分钟才能运行,因此我使用启发式排序jsons,希望最长的任务首先在列表中,因此首先启动.

该json2features任务完成后还会打印该功能.它全部运行在一个拥有48个核心的ubuntu服务器上,就像我上面所说的那样,使用全部47个核心,它开始很棒.然后,当任务完成时,运行的核心越来越少,这听起来完全没问题,不是因为在最后一个核心完成之后(当我看到它打印到stdout时),所有CPU都开始在新任务上再次运行,这意味着这不是真正的清单结束.它可能会再次执行相同的操作,然后再次执行列表的实际结束.

有时它可以在5分钟内只使用一个核心,当任务最终完成时,它会在新任务上再次开始使用所有核心.(所以它不会停留在某些IPC开销上)

没有重复的jsons,也没有任何依赖关系(它们都是静态的,新鲜的磁盘数据,没有引用等等),也没有任何json2features调用之间的依赖关系(没有全局状态或任何东西),除了它们使用相同的终端他们的印刷品

我怀疑问题是工作人员在get调用结果之前不会被释放,所以我尝试了以下代码:

from multiprocessing import Pool
pool = Pool(47)
tasks = [pool.apply_async(print, (i,)) for i in range(1000)]
# feats = [t.get() for t in tasks]

并且它会打印所有1000个数字,即使get没有被调用.

我现在已经没想到问题可能是什么了.
这真的是正常行为Pool吗？

非常感谢!