标签: capacity

我正在开发一个新的存储系统,用于包含大约40个应用程序的业务解决方案包.其中一些应用程序生成当前在网络共享文件夹中保存和组织的文档(主要是docx,一些pdf).

应用程序平均每年生成大约150.000-200.000个文档,这些文档应该以更一致和可靠的形式保存(即单独的SQL数据库).

Sharepoint是一个领先的候选者,因为我们计划最终使用它的其他功能,而不是DMS功能.我已经阅读了文档库的限制,即.每个文件夹2000个文件,文档库的所有文件夹中最多包含1.000.000个文件.我还读到可以绕过2000限制,但它会影响性能.我没有找到的是在一个库中存在如此大量文件的真实世界体验.例如,如果我将文件夹限制增加到50.000,会对性能产生什么影响(通过Web服务读取/编辑/编写文档的请求较慢,尤其是在检查重复文件名,索引,搜索等时写入)会发生什么？ ).

一个重要的注意事项:如果我们不需要,我们根本不会使用sharepoint Web门户,而是通过我们的应用程序通过Web服务完成所有工作,因此数据视图较慢的渲染不是问题.

我有一些类的ArrayList字段只是有时使用。我通常像这样初始化这些字段：

private List<Widget> widgets = new ArrayList<>();

我了解使用重载构造函数来设置初始容量，所以我想知道是否应该这样声明这些字段：

private List<Widget> widgets = new ArrayList<>(0);

困境在于，如果我用 0 初始化列表，那么列表将始终必须重新初始化自己才能添加一项​​。但是，如果我使用默认构造函数，它的默认容量为 10，那么我可能会有一堆项目（并且可能有很多）正在浪费未使用容量的内存。

我知道你们中的一些人会拒绝询问“多久一次”和“你期待多少项目”，但我真的在寻找“最佳实践”方法。所有事情都相等，是否应该使用有时使用的列表(0)或()在列表上进行初始化？

始终初始化列表是我们部门的政策，因此我可能不会简单地将列表保留为null，此外，这只会回避问题。

对于java.util中的数组和容器,Java(可能是底层的C-ish代码)的最大容量为Integer.MAX_VALUE(约20亿).是否有其他语言的容量更大的容器？

我写过程序解决有限的生产者和消费者问题.构建ArrayBlockingQueue我定义的容量100.我正在使用方法take并放入内部线程.而且我注意到有时候我会看到102次与他们之间的任何拍摄.为什么会这样？

生产者运行方法:

public void run() {
    Object e = new Object();
    while(true) {
        try {
            queue.put(e);
        } catch (InterruptedException w) {
                System.out.println("Oj, nie wyszlo, nie bij");
        }
        System.out.println("Element added");

    }
}

消费者运行方法:

public void run() {
    while(true) {
        try {
            queue.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Element removed");
    }
}

部分带有输出的uniq -c文件:

102 Element removed
102 Element added
102 Element removed
102 Element added
102 Element removed
102 Element added
102 Element removed
102 Element added …

今天我在VS2012和Max OS 10.7中尝试这样的东西

    vector<int> vec;
    vector<int> vec2;
    for(int i = 0;i < 100 ;i++){
        vec.push_back(i);
    }

    cout << "size: " << vec.size() << endl;
    cout << "capacity: " << vec.capacity() << endl;
    cout << vec[127] << endl;
    //vec2.reserve(10);
    fill_n(vec.begin(),128,-1);
    cout << vec[127] << endl;
    return 0;

因为我们知道vector的大小是容器中元素的实际数量,上面的代码可能会导致VS2012中的运行时错误,但它在Max OS上运行正常,我在Ideone.com中尝试并且运行成功,我是不确定大小和容量的定义是否有问题,为什么我可以访问元素超出规模？

PS:我的电脑在这种情况下的容量在VS2012上是141,在Mac OS和Ideone.com上是128

环境:OS X 10.8,Go 1.0.2

我创建一个缓冲区大小为2的通道,然后如果我写通道三次,它将抛出错误:

扔:所有的goroutines都睡着了 - 僵局!

当然,这是正确的.

但是如果我在goroutines中写入通道四次或更多次,它工作正常,为什么？频道的容量是2,为什么goroutines会忽略或忽略容量设置？我评论了读取通道代码,因此没有人会读取通道并保存容量.我也用time.Sleep等待所有goroutines完成他们的工作.

请查看以下代码:package main

//import "fmt"

func main() {
    c := make(chan int, 2)
    /*c <- 1
    c <- 2
    c <- 3*/
    for i:=0; i<4; i++ {
        go func(i int) {
            c <- i
            c <- 9
            c <- 9
            c <- 9
        }(i)
    }
    time.Sleep(2000 * time.Millisecond)

    /*for i:=0; i<4*2; i++ {
        fmt.Println(<-c)
    }*/
}

有人会请点击一下吗？多谢你们.

我正在尝试使用Drive SDK将文件上传到Google云端硬盘.

我想知道是否有一种API方法来检查用户的驱动器是否有足够的容量来保存文件.如果是的话,请你指点我应该搜索的地方,如果没有,最好的办法是什么？

PS:请假设我知道要上传的文件的大小.

在我之前提出的问题之后:我正在实施ByteArrayOutputStream容量限制.我的主要限制是可用内存量.所以有这样的流os:

1. 当我写1MB输出流以上时,我需要"停止".我不想抛出异常,而是将os 输出流的完整内容写入指定的其他输出流参数. OutputStream out; os.writeTo(out); 然后继续os从一开始就写作

2. 为了防止1中描述的情况,我倾向于os尽可能频繁地消耗.我的意思是将数据从它复制到out512KB的块中是否可行？如果是,任何建议怎么办？或者可能有一个内置的课程来满足我的要求

编辑:写入的字节out数也是有限的.我可以在那里写高达1GB.如果我有更多,我需要创建其他输出流,以便从os那里流失.写入操作系统的过程.可以那样.在那里写了500MB - 我将它立即转移到了外面.几秒钟之后就写了700MB - 我需要只消耗500MB到out其他200MB到其他输出流(out2),我需要在这种情况下创建

假设我有一个 lambda 函数，并且作为事件参数，我得到了大约 50 个主 id，我必须在 dynamodb 表中查找它们，那么更好的方法是什么 - 50 个查询，每个查询由不同的主 id 或一次扫描然后将扫描主 ID 结果与作为参数接收的主 ID 进行比较？

我认为 50 个 get 查询在性能方面会更好，因为如果明天我将有 100 万条记录，那么扫描所有记录然后仅过滤其中的 50 条将浪费时间和内存，但另一方面却不会对 dynamodb 的 50 个请求可能会出现性能问题并需要更多配置？

我目前正在进行“Rust by Practice”练习。在“Collection Types > HashMap”部分有一个示例：

use std::collections::HashMap;
fn main() {
    let mut map: HashMap<i32, i32> = HashMap::with_capacity(100);
    map.insert(1, 2);
    map.insert(3, 4);
    // Indeed ,the capacity of HashMap is not 100, so we can't compare the equality here.
    assert!(map.capacity() >= 100);
    
    println!("Capacity #1: {}", map.capacity());

    // Shrinks the capacity of the map with a lower limit. It will drop
    // down no lower than the supplied limit while maintaining the internal rules
    // and possibly leaving some space in accordance …