Question

我有一个ArrayList，动态添加数据。

ArrayList<Double> al = new ArrayList<Double>();
while ( data !=null ){
  al.add(data);
}

问题是 1.如何在一秒钟内获得数据的大小？ 2.如果实时添加数据，可以使用ArrayList吗？因此，我尝试通过替换随机生成的数据而没有实际数据。这是我到目前为止所做的。

static long startTime = System.currentTimeMillis();
static double sec = 5;
static double ans;
static double whenToEnd = 30;
static int i = 0;
int ii = 1;
static ArrayList<Double> al = new ArrayList<Double>();
private static int DataLengthIn1s;
static int previousLength = 0;

public static void main(String[] args) {
    // TODO Auto-generated method stub

    while ((System.currentTimeMillis() - startTime) < whenToEnd * 1000) {

        writeData();

        System.out.println("Current size of al: " + al.size());
    }

    System.out.println("Total size of al: " + al.size());

    long endTime = System.currentTimeMillis();
    long totalTime = (endTime - startTime);
    System.out.println("Total process time: " + totalTime);
}


public static void writeData() {
    long innerStartTime = System.currentTimeMillis();

    while ((System.currentTimeMillis() - innerStartTime) < sec * 1000) {
        ans = getRandom();
        al.add(i, ans);
        getDataLengthIn1s(innerStartTime);
        i++;
    }
}

private static int getDataLengthIn1s(long innerStartTime) {
    if ((System.currentTimeMillis() + innerStartTime) == 1000) {
        int length = al.size() - previousLength;
        System.out.println("In one second, data added are: " + length);
        previousLength = al.size();
    }
    return 0;
}

private static double getRandom() {
    // TODO Auto-generated method stub
    double lower = 0;
    double upper = 1;

    double result = Math.random() * (upper - lower) + lower;
    try {
        TimeUnit.MILLISECONDS.sleep(50);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return result;

}

在此代码中，我获得600个数据30秒。意味着，600/30 = 20数据/秒。但是对于实际的实现，发送一秒钟的数据不会一直相同。另一个原因是我可以通过了解当前添加数据的大小来删除以前的数据。提前谢谢..

Answer 1

如何在一秒钟内获得数据的大小？

如果您想知道在最后一秒中有多少项目已添加到列表中，那么您可以检查列表中当前有多少项目，等待一秒钟，然后再次检查列表中有多少项目。但请注意，此测量不准确，因为等待时间受调度程序的影响。

在下面的代码片段中，一个线程会检查最后一秒在列表中添加了多少项：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;

public class ListPerformance {
    public static void main(String[] args) {
        final AtomicBoolean stop = new AtomicBoolean(false);
        final List<Double> queue = new ArrayList<Double>();
        Thread producer = new Thread(new Runnable() {
            public void run() {
                while (!stop.get()) {
                    queue.add(Math.random());
                    try {
                        Thread.sleep(Math.round(Math.random() * 10));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread timer = new Thread(new Runnable() {
            public void run() {
                while (!stop.get()) {
                    int startingSize = queue.size();
                    long startingTime = System.currentTimeMillis();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Added " + (queue.size() - startingSize) + " items in " + (System.currentTimeMillis() - startingTime) + " ms");
                }
            }
        });
        producer.start();
        timer.start();
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        stop.set(true);
    }
}

结果可能是：

Added 190 items in 1000 ms
Added 193 items in 1000 ms
Added 208 items in 1000 ms
Added 200 items in 1000 ms
...

请注意，列表在两个线程之间共享。如果你想在一个线程中从列表中删除项目并在第二个线程中添加项目，那么你绝对必须在生成和消费线程中锁定列表，例如synchronized(queue){...。很可能还存在许多优化的线程安全列表实现。

我不确定你的最终目标是什么，但你也可以考虑创建一个关于每一秒的新列表（我将它与一定数量的数据而不是时间联系起来）并拥有多个独立的数据集合而不是一个巨大的集合。这样，您可以丢弃您不需要的整个列表，而不是修改您的唯一列表。

如果实时添加数据，可以使用ArrayList吗？

如果您正在谈论一个真正的实时系统，那么我不认为列表实现是您应该关注的。更关键的是线程和垃圾收集的调度。我无法告诉您如何实现实时系统，但如果您考虑使用Java，可能需要查看Real Time Garbage Collector。

如果您不是在谈论真正的实时，而只是想知道是否有更好的收藏品供您使用，那么 - 根据您的描述 - 您可能想要搜索 Java Buffer 或 Java Queue 并决定是否找到适合您特定用例的内容。

如何确定ArrayList中一秒钟内添加的数据大小？

1 个答案: