Java 如何在我的程序中加速/优化文件写入

嗯。我应该写一个程序，将一个20GB的文件作为输入，包含100000000条记录，并创建某种索引，以便更快地访问。我基本上已经决定将1bil记录分成10个存储桶和其中的10个子存储桶。我正在为记录计算两个散列值，以定位其适当的存储桶。现在，我创建10*10个文件，每个子bucket一个。当我对输入文件中的记录进行散列时，我决定它将进入100个文件中的哪一个；然后将记录的偏移量附加到该特定文件。 我已经用一个包含10000条记录的示例文件对此进行了测试。我已经重复了10次这个过程。有效地模拟100000个记录文件。为此，我花了大约18秒。这意味着我要花很长时间才能对一个1 bil的记录文件做同样的事情。 我有没有办法加快/优化我的写作速度。 我经历了所有这些，因为我无法将所有记录存储在主内存中

import java.io.*;

// PROGRAM DOES THE FOLLOWING

// 1. READS RECORDS FROM A FILE. 
// 2. CALCULATES TWO SETS OF HASH VALUES N, M
// 3. APPENDING THE OFFSET OF THAT RECORD IN THE ORIGINAL FILE TO ANOTHER FILE "NM.TXT"  i.e REPLACE THE VALUES OF N AND M.
// 4.  

class storage
{

        public static int siz=10;
    public static FileWriter[][] f;
}

class proxy
{

    static String[][] virtual_buffer;
    public static void main(String[] args) throws Exception
    {
        virtual_buffer = new String[storage.siz][storage.siz]; // TEMPORARY STRING BUFFER TO REDUCE WRITES


        String s,tes;


        for(int y=0;y<storage.siz;y++)
            {
            for(int z=0;z<storage.siz;z++)
            {
            virtual_buffer[y][z]="";            // INITIALISING ALL ELEMENTS TO ZERO
            }
            }




        int offset_in_file = 0;          

        long start = System.currentTimeMillis();


              // READING FROM THE SAME IP FILE 20 TIMES TO EMULATE A SINGLE BIGGER FILE OF SIZE 20*IP FILE
        for(int h=0;h<20;h++){                

         BufferedReader in = new BufferedReader(new FileReader("outTest.txt"));
         while((s = in.readLine() )!= null)
         {
            tes = (s.split(";"))[0];
            int n = calcHash(tes); // FINDING FIRST HASH VALUE
            int m = calcHash2(tes); // SECOND HASH
            index_up(n,m,offset_in_file); // METHOD TO WRITE TO THE APPROPRIATE FILE I.E NM.TXT
                offset_in_file++;

         }
         in.close();
        }



         System.out.println(offset_in_file);
         long end = System.currentTimeMillis();
         System.out.println((end-start));
    }




    static int calcHash(String s) throws Exception

    {
        char[] charr = s.toCharArray();;
        int i,tot=0;
        for(i=0;i<charr.length;i++)
        {
            if(i%2==0)tot+= (int)charr[i];
        }
        tot = tot % storage.siz;
        return tot;
    }




       static int calcHash2(String s) throws Exception

    {
        char[] charr = s.toCharArray();
        int i,tot=1;
        for(i=0;i<charr.length;i++)
        {
            if(i%2==1)tot+= (int)charr[i];
        }   
        tot = tot % storage.siz;
        if (tot<0)
            tot=tot*-1;
        return tot;
    }


      static void index_up(int a,int b,int off) throws Exception
   {
    virtual_buffer[a][b]+=Integer.toString(off)+"'"; // THIS BUFFER STORES THE DATA TO BE WRITTEN
    if(virtual_buffer[a][b].length()>2000)           // TO A FILE BEFORE WRITING TO IT, TO REDUCE NO. OF WRITES
    {                                                .

    String file = "c:\\adsproj\\"+a+b+".txt";   
    new writethreader(file,virtual_buffer[a][b]);    // DOING THE ACTUAL WRITE PART IN A THREAD.
    virtual_buffer[a][b]="";


    }
    }
}



class writethreader implements Runnable
{
    Thread t;
    String name, data;
    writethreader(String name, String data)
    {
        this.name = name;
        this.data = data;

        t = new Thread(this);
        t.start();
    }

    public void run()
    {
        try{


        File f = new File(name);
        if(!f.exists())f.createNewFile();   
        FileWriter fstream = new FileWriter(name,true);  //APPEND MODE 
        fstream.write(data);
        fstream.flush(); fstream.close();
            }
        catch(Exception e){}
    }
}

import java.io.*；
//程序执行以下操作
// 1. 从文件中读取记录。
// 2. 计算两组散列值N，M
// 3. 将原始文件中该记录的偏移量附加到另一个文件“NM.TXT”，即替换N和M的值。
// 4.  
类存储
{
公共静态int siz=10；
公共静态文件编写器[][]f；
}
类代理
{
静态字符串[][]虚拟_缓冲区；
公共静态void main（字符串[]args）引发异常
{
virtual_buffer=新字符串[storage.siz][storage.siz]；//用于减少写入的临时字符串缓冲区
字符串s，tes；
对于（int y=0；y可以考虑使用VisualVM来找出瓶颈。下面的所有内容都是基于猜测，而性能猜测通常是非常非常错误的

我认为你的写作策略有两个问题

第一个是每次写入时启动一个新线程；第二个是每次写入时打开文件

线程问题尤其糟糕，我认为，因为我没有看到任何东西阻止一个线程在文件上写入另一个线程。然后会发生什么？坦率地说，我不知道-但我怀疑它是否好

相反，请考虑为所有100个打开的文件创建一个数组。您的操作系统可能有问题，但我认为可能没有。然后为每个文件创建一个工作队列。在每个“拥有”的位置创建一组工作线程（100个太多，大约10个）它循环通过的一组文件，输出并清空每个文件的队列。注意队列读取器和写入器之间的线程间交互-使用适当的队列类。
考虑使用VisualVM来确定瓶颈。下面的所有内容都基于猜测-性能猜测通常是真实的，真的错了

我认为你的写作策略有两个问题

第一个是每次写入时启动一个新线程；第二个是每次写入时打开文件

线程问题尤其糟糕，我认为，因为我没有看到任何东西阻止一个线程在文件上写入另一个线程。然后会发生什么？坦率地说，我不知道-但我怀疑它是否好

相反，请考虑为所有100个打开的文件创建一个数组。您的操作系统可能有问题，但我认为可能没有。然后为每个文件创建一个工作队列。在每个“拥有”的位置创建一组工作线程（100个太多，大约10个）它循环通过的一组文件，输出并清空每个文件的队列。注意队列读取器和写入器之间的线程间交互-使用适当的队列类。
我会放弃整个需求，使用数据库。
我会放弃整个需求，使用数据库。
是目标吗这个项目的目的仅仅是提供一种快速查找特定记录的机制？数据是否被修改？使用NIO。获得大量内存。一些注释，而不是核心Java开发：1），Java字符串是不可变的，所以这在性能上非常糟糕：virtual_buffer[a][b]+=Integer.toString（off）+“”；--改用StringBuilder。和2）新的writethreader（文件，虚拟缓冲区[a][b]）；这会生成虚拟缓冲区[a][b]的副本，这可能也不是很有效。您尝试过预优化写入，但您测试过这一点吗？您的两个“优化”这可能会使速度变慢。我想知道我是否正确理解了您的哈希函数。两者都返回一个int值%10，即0..9？不要使用
s.split（；）
由于
split
使用正则表达式且成本高昂，请实现
StringTokenizer
。检查哈希函数是否存在冲突。此项目的目标是否只是提供一种机制来快速查找特定记录？数据是否被修改？使用NIO。获得大量内存。一些注释，而不是核心Java开发人员：1），Java字符串是不可变的，因此这在性能上非常糟糕：virtual_buffer[a][b]+=Integer.toString（off）+“'”；--使用StringBuilder。以及2）新的writethreader（文件，virtual_buffer[a][b]）；这会生成virtual_buffer[a][b]的副本这也可能不是很有效。您尝试过预优化写入操作，但您是否测试过仅将单个记录写入？您的两次“优化”可能会使速度变慢。我想知道我是否正确理解您的哈希函数。两者都返回一个整数值%10，即0..9？不要使用
s.split（“；”）
由于
split
使用正则表达式且成本高昂，请实现
StringTokenizer
。检查您的哈希函数是否存在冲突。我最初没有线程。我这样做是为了看看它是否使事情变得更好。没有多大用处。将删除。我将尝试您的建议。非常感谢。我最初没有线程。我这样做是为了看看是否它使事情变得更好。没有多大用处。将删除。我会试试你的建议