标签: pool

我有一个 couchdb 数据库，并且正在并行查询它。现在，我想创建一个连接池，因为我发现了设计中的瓶颈 - 我使用的是 couchd 的单个实例，因此并行化因此失败。

我在网上搜索了连接池实现，但我无法找到适合 couchdb 的正确 java 连接池实现 - 大多数框架都支持关系数据库。如果有人能帮助我，我将不胜感激。

我的解决方案需要许多常量变量，因此在进一步的开发中，我可以简单地创建新的原语或引用现有数据，而不是创建新的原语，这排除了未来开发过程中可能出现的错误。

我读过java池常量变量，当创建新数据时，它与池进行比较，如果这样的对象存在，它返回对现有对象的引用，而不是创建新的对象。

虽然池化可能听起来是最好的方法，但就我而言，我需要许多短变量，每个变量分配 2 个字节（对于原语）。但如果我创建Short我会丢失 2 个字节，因为引用将占用 4 个字节。

即使考虑到 Short 使用池化，仍然使用原语是否有意义。另外，从短到短的拆箱也需要一些资源（几乎接近于零，但仍然如此）。请注意，short 必须时常转换为原始 3 字节数组，因此另一个 + 表示原始。

public static final short USER = 10;

代替

public static final Short USER = 10;

当使用文字创建字符串时，它会存储在池中。但是当使用 new 运算符创建 String 对象时，它将对象存储在 Heap 中。

但是堆中的对象只是指向存储在池中的文字的指针还是存储在堆中的简单 String 对象符合 GC 条件？

我想知道是否可以sync.Pool与数组或切片一起使用？例如，sync.Pool每秒处理数万个请求时是否可以加快以下速度？这个例子只是为了更好地理解 Go。

// Handler that uses GenerateArray
func ok(w http.ResponseWriter, r *http.Request) {
    var res [100000]uint64
    fibonacci.GenerateArray(&res)
    fmt.Fprintf(w, "OK")
}

func GenerateArray(data *[100000]uint64) {
    var start uint16 = 1000
    var counter uint32
    for start >= 1 {
        var num = 90
        var n1, n2, temp uint64 = 0, 1, 0

        for num >= 1 {
            temp = n2
            n1, n2 = temp, n1+n2
            data[counter] = n2
            counter++
            num--
        }
        start--
    }
}

编辑：这是 Icza 建议的切片版本。希望我在学习时做得对。 …

我知道如果我有 2 个具有相同值的字符串变量，由于 java 字符串池，它们指向同一个字符串对象。

下面是一个例子：

String test = "1234";
String test2 = "1234";
    
System.out.println(test == test2);
System.out.println("1234" == test2);

输出如下：

true
true

但是如果我有以下代码，它会打印出它们不是同一个对象

String test = "1234";
int i = 1234;
String s = "" + i;
    
System.out.println(test == s);
System.out.println("1234" == s);

输出：

false
false

任何人都会向我解释这种行为的原因吗？

我正在寻找一种使用 R 处理连接数据库的方法，这样我就不必将数据库上传到我的内存中。我一直在使用pool或DBI包连接到数据库并dplyr进行数据操作，但我发现了一些我无法解决的问题：

加载数据：

library(pool)
library(dplyr)
library(RMariaDB)

my_db <- dbPool(
  MariaDB(),
  donate = "aaa",
  host = "localhost",
  username = "root"
)

- 第一个问题：无法使用切片功能

my_db %>% tbl("bbb") %>%
  slice(2:10)
#Error: slice() is not supported on database backends

对于这个问题我想出了这个解决方法：

my_db %>% tbl("bbb") %>%
  mutate(Rowindx = row_number()) %>%
  filter(Rowindx >= 2 && Rowindx <= 10) 

这对我有用，但我想知道是否有更好的解决方案来解决这个问题

- 第二个问题：无法使用以下命令更改列的类或类型 transmute()

我有一个列类字符，我想将其更改为因子。我尝试过以下代码，它可以在没有连接的数据库的情况下工作。

my_db %>% tbl("bbb") %>%
  transmute (colname = factor(colname))
#Error: FUNCTION aaa.factor does not exist [1305]

对于这个问题，我还没有想出任何解决方案，任何有关 …

以某种方式使用boost :: object_pool <> :: construct和非const引用是否可行？

以下代码段无法编译(VS2010):

foo::foo(bar & b)
{
}

static boost::shared_ptr<foo> foo::create(bar & b)
{
  return boost::shared_ptr<foo>(foo_pool.construct(b),
    boost::bind(& boost::object_pool<foo>::destroy, & foo_pool, _1));
}

VS2010抱怨无法将bar转换为const bar&.看看boost :: object_pool <> :: construct,原因很清楚:

element_type * construct(const T0 & a0)

我不能使ctor参数const.是否有一个技巧使boost :: object_pool <>与我的foo类一起工作？

我正在尝试为我的Web应用程序建立连接池,但不知道如何使用它设置sql server的基础知识

主要问题:什么是资源类型(写什么),classname,driverclass名称？

public static void main(String[] args) throws ClassNotFoundException, SQLException {
    String str="SELECT * from Book";
    Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
        try {
            Connection con = DriverManager.getConnection("jdbc:odbc:lol","Sar\\KILLER_GUY",null);
            Statement stmt=con.createStatement();
            ResultSet rs=stmt.executeQuery(str);
            System.out.println("SalesPerson Id: ");
            while(rs.next())
            {
                String id= rs.getString("Add");
            System.out.println(id);
            }
            con.close();
        }
    catch(SQLException e)
    {

    }

我有这个非常简单的python代码,我希望通过并行化来加速它.然而,无论我做什么,multiprocessing.Pool.map都不会在标准地图上获得任何东西.

我已经读过其他线程,其中人们使用这个非常小的函数,这些函数不能很好地并行化并导致过多的开销,但我认为这不应该是这种情况.

难道我做错了什么？

这是一个例子

#!/usr/bin/python

import numpy, time

def AddNoise(sample):
    #time.sleep(0.001)
    return sample + numpy.random.randint(0,9,sample.shape)
    #return sample + numpy.ones(sample.shape)

n=100
m=10000
start = time.time()
A = list([ numpy.random.randint(0,9,(n,n)) for i in range(m) ])
print("creating %d numpy arrays of %d x %d took %.2f seconds"%(m,n,n,time.time()-start))

for i in range(3):
    start = time.time()
    A = list(map(AddNoise, A))
    print("adding numpy arrays took %.2f seconds"%(time.time()-start))

for i in range(3):
    import multiprocessing
    start = time.time()
    with multiprocessing.Pool(processes=2) as pool:
        A = list(pool.map(AddNoise, A, …

我读了sync.Pool设计，但发现有两种逻辑，为什么我们需要localPool来解决锁竞争。我们可以使用chan来实现一个。

使用频道的速度是的4倍sync.pool！

除了池可以清除对象外，它还有什么优势？

这是池实现和基准测试代码：

package client

import (
    "runtime"
    "sync"
    "testing"
)

type MPool chan interface{}


type A struct {
    s        string
    b        int
    overflow *[2]*[]*string 

}

var p = sync.Pool{
    New: func() interface{} { return new(A) },
}

var mp MPool = make(chan interface{}, 100)

func get() interface{} {
    select {
    case r := <-mp:
        return r
    default:
        return new(A)
    }
}

func put(a interface{}) {
    select {
    case mp <- a:
    default:
    }
    return …

我有一些代码需要从数百个网页中获取数据，我想通过为其运行多个 Selenium Chrome 浏览器实例来加快速度。例如我这里有这个代码：

from selenium import webdriver
from multiprocessing import Pool
from tkinter import *

#initiate browser
def browser():
    global driver
    driver = webdriver.Chrome(r"C:\Users\areed\Desktop\p\chromedriver.exe")
    return driver

#test link
def test():
    links = [link1.com, link2.com, link3.com, link4.com]
    browser()
    for l in links:
        driver.get(l)
        dostuff(driver)

#Scrape Data
def dostuff(driver):
    print('doing Stuff')

#multiprocess Function      
def multip():
    pool = Pool(processes=4)
    pool.map(test())

#tkinter Window
if __name__ == "__main__":  
    win = Tk()
    win.title("test")
    win.geometry('300x200')
    btn = Button(win, text="Tester", command=multip)
    btn.pack()
    win.mainloop()

我怎样才能让这段代码运行多个 selenium chrome 浏览器？这段代码在不添加多进程的情况下工作得很好。有人可以向我解释一下如何解决这个问题吗？谢谢！

我想改变一个类似的代码

if("T".equalsIgnoreCase(bo.getSubjectType()))  //method-1

至

if(String.valueOf('T').equalsIgnoreCase(bo.getSubjectType()))  //method-2

因此,我写了一个示例代码

String s1 = "T";
String s2 = "T";
char c1 = 'T';
char c2 = 'T';
System.out.println(String.valueOf(c1) == String.valueOf(c2));   //  false
System.out.println(s1 == s2);   //  true

几乎所说的String.valueOf(arg)产生了一个字符串文字并放入其中constant pool.所以我的问题是,当我们尝试操作non-constant池中的字符串时,性能是否会有任何对比,并且在constant pool- 基本上哪一个更好地接近方法-1或方法-2？