将多个文件并行读入缓冲区

Question

我在一个项目中工作，我必须读取一组文件并将其放入缓冲区中。列表由小文件和大文件组成。我必须阅读这些文件，为了提高效率，我尝试在多个线程。每个线程将从文件名向量中获取一个文件并开始读取它并将其放入缓冲区中，这些缓冲区必须放入队列中。我碰巧在程序中有一些错误，我不知道到底在哪里在我的程序中出现错误也不知道为什么？请帮助我在我的逻辑或代码中是否有任何错误以及如何纠正它。在此先感谢

using namespace std;
#define MAX_THREADS 2
#define BUFFER_SIZE 8388608
vector<string>files;
deque<string>bufferq;
CRITICAL_SECTION Readlock;
int count = 0;

DWORD WINAPI ReadThread(LPVOID s);
int main(int argc,char *argv[])
{
    HANDLE ReadT[MAX_THREADS];

    char *filelist[5];
    DWORD threadid;
    filelist[0] = "1.txt";
    filelist[1] = "cloudy.jpg";
    filelist[2] = "connectify.exe";
    filelist[3] = "VMware.exe";
    filelist[4] = "Sherlock.mp4";
    for(int i=0;i<5;i++)
        files.push_back(filelist[i]);

    InitializeCriticalSection(&Readlock);
    long t1 = GetTickCount();
    for(int k = 0; k< MAX_THREADS; k++)
        ReadT[k] = CreateThread(NULL,0,ReadThread,NULL,NULL,&threadid);

    WaitForMultipleObjects(MAX_THREADS,ReadT,TRUE,INFINITE);
    cout << " Time Taken "<< GetTickCount()-t1 << "ms" ;

    system("pause");
    return 0;
}
DWORD WINAPI ReadThread(LPVOID s)
{
    long pending = 0;
    //int freespace = BUFFER_SIZE;
    char *filename = new char[50];
    char fsize[10];
    string file;
    char *buf;
    buf = new char[BUFFER_SIZE];
    long filesize = 0;
    int numfiles = files.size();
    int filled = 0;
    int i = 0;
    FILE *fp;
    char* ptr;
    ptr = buf;

    while(true)
    {
        EnterCriticalSection(&Readlock);
        if(files.empty())
        {
            LeaveCriticalSection(&Readlock);
            break;
        }
        else
        {
            file = files.front();
            files.erase(files.begin());
            LeaveCriticalSection(&Readlock);
        }
        bool buff_full = false;
        buf = ptr;
        int freespace = BUFFER_SIZE;
        memset(buf,0,BUFFER_SIZE);
        if(!buff_full)
        {
            if(pending == 0)
            {
                fp = fopen(file.c_str(),"rb");
                if(!fp)
                    {
                        cout<<"\nNo such file";
                        cout<<files[i];
                        system("pause");
                        return 0;
                    }
                int r1 =fseek(fp, 0L, SEEK_END);
                filesize = ftell(fp);
                int r2 =fseek(fp, 0L, SEEK_SET);
                sprintf(fsize, "%ld", filesize);
                if(freespace >= (strlen(fsize) + strlen(file.c_str()) + 2))
                {
                    count++;
                    memcpy(buf, file.c_str(), strlen(file.c_str())+1);
                    freespace = freespace - strlen(file.c_str()) - 1;
                    buf += strlen(file.c_str()) + 1;
                    memcpy(buf,fsize,strlen(fsize)+1);
                    buf += strlen(fsize) + 1;
                    freespace = freespace - strlen(fsize) - 1;
                    cout<<"Files read is "<<count<<"\n";
                    if(freespace == 0)
                    {
                        buff_full = true;
                        pending = filesize;
                        break;
                    }
                }
                else
                {
                    filled = BUFFER_SIZE - freespace;
                    fclose(fp);
                    break;
                }
                if(freespace >= filesize)
                {
                    fread(buf, 1, filesize, fp);
                    buf += filesize;
                    freespace = freespace - filesize;
                    bufferq.push_back(buf);
                    //cout << "pop"<<bufferq.size();
                    //i++;
                    if(files.empty())
                    {
                        filled = BUFFER_SIZE - freespace;
                        fclose(fp);
                        break;
                    }
                    fclose(fp);
                }
                else
                {
                    fread(buf, 1, freespace, fp);
                    bufferq.push_back(buf);
                    //cout <<"pop "<<bufferq.size();
                    buff_full = true;
                }
            }
            else
            {
                if(freespace >= pending)
                {
                    fread(buf, 1, pending, fp);
                    bufferq.push_back(buf);
                    freespace = freespace - pending;
                    pending = 0;
                    //i++;
                    if(files.empty())
                    {
                        filled = BUFFER_SIZE - freespace;
                        fclose(fp);
                        break;
                    }
                    if(freespace > 0)
                        buf += pending;
                    else
                        buff_full = true;
                    fclose(fp);
                }
                else
                {
                    fread(buf, 1, freespace, fp);
                    bufferq.push_back(buf);
                    cout << bufferq.size();
                    pending = pending - freespace;
                    buff_full = true;
                }
            }
        }
        if(buff_full)
        {
            buf = ptr;
            cout << "popping buffer " << bufferq.size();
            //bufferq.pop_back();
        }
    }
    return 0;
}

Answer 1

在大文件发生错误的情况下，我认为这行可能会导致问题

sprintf(fsize, "%ld", filesize);

fsize 是 char[10]，如果文件大小 >= 1,000,000,000，您将用尾随 0 覆盖 fsize 数组。这将导致“运行时检查失败 #2 - 变量 'fsize' 周围的堆栈已损坏。” ，正如你所写。请检查您的测试文件的大小。

其中，您正在 i 上循环填充文件，然后您写道：

files.erase(files.begin());
// ...
cout<<"\nNo such file";
cout<<files[i];

files[i] 在您删除它们时已经指向另一个元素，如果文件在最后一次迭代中为空，则会导致崩溃。

如果你不将文件和fsize复制到bufferq，你又是为了什么？

由于 bufferq 是可写的并且在线程之间共享，所以对它的访问应该受到锁的保护，你选择的关键部分。

这是我的小代码审查。