파일에서 바이트 범위 잠금 및 잠금 해제
시스템에서 둘 이상의 애플리케이션이 파일을 열고 파일에 쓸 수 있지만 애플리케이션은 서로의 작업을 덮어쓰기해서는 안 됩니다. 애플리케이션은 파일에서 바이트 범위를 일시적으로 잠그면 이 문제를 방지할 수 있습니다.
LockFile 및 LockFileEx 함수는 파일에서 지정된 바이트 범위를 잠급니다. 범위는 파일의 현재 끝을 넘어 확장될 수 있습니다. 파일의 일부를 잠그면 잠금 프로세스의 스레드가 지정된 파일 핸들을 사용하여 지정된 바이트 범위에 대한 단독 액세스 권한을 부여합니다. 다른 프로세스에 의해 잠긴 바이트 범위에 액세스하려고 시도하면 항상 실패합니다. 잠금 프로세스가 두 번째 파일 핸들을 통해 잠긴 바이트 범위에 액세스하려고 하면 시도가 실패합니다.
참고
메모리 매핑 파일을 사용할 때는 바이트 범위 잠금이 무시됩니다.
LockFileEx 함수를 사용하면 애플리케이션에서 두 가지 잠금 유형 중 하나를 지정할 수 있습니다. 배타적 잠금은 다른 모든 프로세스의 파일의 지정된 바이트 범위에 대한 읽기 및 쓰기 액세스를 모두 거부합니다. 공유 잠금은 먼저 바이트 범위를 잠그는 프로세스를 포함하여 파일의 지정된 바이트 범위에 대한 모든 프로세스의 쓰기 액세스를 거부합니다. 파일에서 읽기 전용 바이트 범위를 만드는 데 사용할 수 있습니다.
애플리케이션은 UnlockFile 또는 UnlockFileEx 함수를 사용하여 바이트 범위의 잠금을 해제하고 파일을 닫기 전에 잠긴 모든 영역의 잠금을 해제해야 합니다.
LockFile을 사용하는 예제는 한 파일을 다른 파일에 추가를 참조하세요.
다음 예제에서는 LockFileEx를 사용하는 방법을 보여 줍니다. 첫 번째 예제는 파일을 만들고, 일부 데이터를 작성한 다음, 중간에 섹션을 잠그는 간단한 데모입니다.
참고 이 예제에서는 파일이 잠긴 후 데이터를 변경하지 않습니다.
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (C) Microsoft. All rights reserved
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#define NUMWRITES 10
#define TESTSTRLEN 11
const char TestData[NUMWRITES][TESTSTRLEN] =
{
"TestData0\n",
"TestData1\n",
"TestData2\n",
"TestData3\n",
"TestData4\n",
"TestData5\n",
"TestData6\n",
"TestData7\n",
"TestData8\n",
"TestData9\n"
};
int main(int argc, char *argv[])
{
BOOL fSuccess = FALSE;
// Create the file, open for both read and write.
HANDLE hFile = CreateFile(TEXT("datafile.txt"),
GENERIC_READ | GENERIC_WRITE,
0, // open with exclusive access
NULL, // no security attributes
CREATE_NEW, // creating a new temp file
0, // not overlapped index/O
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
// Handle the error.
printf("CreateFile failed (%d)\n", GetLastError());
return (1);
}
// Write some data to the file.
DWORD dwNumBytesWritten = 0;
for (int i=0; i<NUMWRITES; i++)
{
fSuccess = WriteFile(hFile,
TestData[i],
TESTSTRLEN,
&dwNumBytesWritten,
NULL); // sync operation.
if (!fSuccess)
{
// Handle the error.
printf("WriteFile failed (%d)\n", GetLastError());
return (2);
}
}
FlushFileBuffers(hFile);
// Lock the 4th write-section.
// First, set up the Overlapped structure with the file offset
// required by LockFileEx, three lines in to the file.
OVERLAPPED sOverlapped;
sOverlapped.Offset = TESTSTRLEN * 3;
sOverlapped.OffsetHigh = 0;
// Actually lock the file. Specify exclusive access, and fail
// immediately if the lock cannot be obtained.
fSuccess = LockFileEx(hFile, // exclusive access,
LOCKFILE_EXCLUSIVE_LOCK |
LOCKFILE_FAIL_IMMEDIATELY,
0, // reserved, must be zero
TESTSTRLEN, // number of bytes to lock
0,
&sOverlapped); // contains the file offset
if (!fSuccess)
{
// Handle the error.
printf ("LockFileEx failed (%d)\n", GetLastError());
return (3);
}
else printf("LockFileEx succeeded\n");
/////////////////////////////////////////////////////////////////
// Add code that does something interesting to locked section, /
// which should be line 4 /
/////////////////////////////////////////////////////////////////
// Unlock the file.
fSuccess = UnlockFileEx(hFile,
0, // reserved, must be zero
TESTSTRLEN, // num. of bytes to unlock
0,
&sOverlapped); // contains the file offset
if (!fSuccess)
{
// Handle the error.
printf ("UnlockFileEx failed (%d)\n", GetLastError());
return (4);
}
else printf("UnlockFileEx succeeded\n");
// Clean up handles, memory, and the created file.
fSuccess = CloseHandle(hFile);
if (!fSuccess)
{
// Handle the error.
printf ("CloseHandle failed (%d)\n", GetLastError());
return (5);
}
fSuccess = DeleteFile(TEXT("datafile.txt"));
if (!fSuccess)
{
// Handle the error.
printf ("DeleteFile failed (%d)\n", GetLastError());
return (6);
}
return (0);
}
다음 예제는 단일 데이터 파일에서 임의 작업을 수행하는 간단한 데이터베이스와 여러 스레드를 사용하는 바이트 범위 잠금의 고급 데모입니다. 자세한 내용은 포함된 코드 주석 및 샘플 코드 다음 섹션을 참조하세요.
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (C) Microsoft. All rights reserved
#define UNICODE
#define _CRT_RAND_S
#include <stdlib.h>
#include <windows.h>
#include <stdio.h>
#include <malloc.h>
#include <conio.h>
#include <process.h>
#include <winioctl.h>
#define RECORD_SIZE 0x300
#define NUM_RECORDS 0x1000
#define NUM_THREADS 8
#define NUM_FILEOPS 500
#define BITMAP_SIZE ((NUM_RECORDS) / 8)
#define DATA_SIZE ((RECORD_SIZE) - sizeof(RECORD_HEADER))
#define MSG_PRINTF(S,...) wprintf(L"[THREAD_ID %d] " S, \
GetCurrentThreadId(), \
__VA_ARGS__)
#if defined BRLS_DEBUG
#define DBG_PRINTF(S,...) wprintf(L"[THREAD_ID %d] " S, \
GetCurrentThreadId(), \
__VA_ARGS__)
#else
#define DBG_PRINTF(...)
#define PrintBitmap(...)
#endif
#define MASTER_RECORD_TYPE_CODE 'rtsM'
#define DATA_RECORD_TYPE_CODE 'ataD'
//
// Record type definitions.
//
typedef struct _RECORD_HEADER {
ULONG TypeCode; // Either MASTER_RECORD_TYPE_CODE or DATA_RECORD_TYPE_CODE.
ULONG SeqNumber; // Starts at 1 and is incremented every time contents are modified.
} RECORD_HEADER;
typedef struct _MASTER_RECORD {
RECORD_HEADER Header;
BYTE Bitmap[BITMAP_SIZE]; // A bitmap indicating which records are allocated.
} MASTER_RECORD;
typedef struct _DATA_RECORD {
RECORD_HEADER Header;
BYTE Data[DATA_SIZE]; // Record raw data.
} DATA_RECORD;
//
// Types of I/O for IoRecord.
//
typedef enum {
IoRead,
IoWrite,
IoLock,
IoUnlock
} IO_TYPE;
//
// Types of operations for OperateOnRecord.
//
typedef enum {
CreateRecord = 0,
DeleteRecord,
ModifyRecord,
MaxOprRecord
} OPERATION;
//
// Parameter block for I/Os passed to IoRecord.
//
typedef struct _IO_PARAM {
IO_TYPE Type;
union _IO_PARAM_PARAMS {
struct {
PVOID Data;
ULONG RecSize;
} IoInfo;
struct {
BOOL Exclusive;
} LockInfo ;
} Params;
} IO_PARAM, *PIO_PARAM;
void ErrorExitThread()
//
// This function is called immediately after an unrecoverable error is logged.
//
{
MSG_PRINTF(L"An error has been logged, calling ExitThread.\n");
ExitThread(1);
}
BOOL IoRecord(HANDLE hFile, ULONG RecNumber, PIO_PARAM pIoParam)
//
// This function performs I/O (read, write, lock or unlock) in a record, according
// to the parameters passed in the IO_PARAM block.
//
// Arguments:
// hFile - Handle to the file containing the records.
// RecNumber - Number of the record to be operated on.
// pIoParam - Pointer to IO_PARAM structure.
//
// Return value:
// TRUE if the I/O succeeded, FALSE if not.
//
{
OVERLAPPED Overlapped;
BOOL Result;
ULARGE_INTEGER RecOffset;
DWORD NumBytes;
// Initialize Overlapped.
SecureZeroMemory(&Overlapped, sizeof(OVERLAPPED));
Overlapped.hEvent = CreateEvent(NULL,
FALSE,
FALSE,
NULL);
if (NULL == Overlapped.hEvent)
{
MSG_PRINTF(L"CreateEvent for Overlapped.hEvent failed with error 0x%08x.\n",
GetLastError());
ErrorExitThread();
}
// Calculate record position.
RecOffset.QuadPart = RecNumber * RECORD_SIZE;
Overlapped.Offset = RecOffset.LowPart;
Overlapped.OffsetHigh = RecOffset.HighPart;
// Issue the operation.
switch (pIoParam->Type)
{
case IoLock:
Result = LockFileEx(hFile,
pIoParam->Params.LockInfo.Exclusive ? LOCKFILE_EXCLUSIVE_LOCK : 0,
0,
RECORD_SIZE,
0,
&Overlapped);
break;
case IoUnlock:
Result = UnlockFileEx(hFile,
0,
RECORD_SIZE,
0,
&Overlapped);
break;
case IoRead:
Result = ReadFile(hFile,
pIoParam->Params.IoInfo.Data,
pIoParam->Params.IoInfo.RecSize,
NULL,
&Overlapped);
break;
case IoWrite:
Result = WriteFile(hFile,
pIoParam->Params.IoInfo.Data,
pIoParam->Params.IoInfo.RecSize,
NULL,
&Overlapped);
break;
default:
Result = FALSE;
break;
}
if (!Result)
{
if (GetLastError() == ERROR_IO_PENDING)
{
// Wait until the operation finishes.
if (GetOverlappedResult(hFile,
&Overlapped,
&NumBytes,
TRUE) == FALSE)
{
MSG_PRINTF(L"GetOverlappedResult for Overlapped.hEvent failed with error 0x%08x.\n",
GetLastError());
ErrorExitThread();
}
Result = TRUE;
} else {
MSG_PRINTF(L"IoRecord failed with error 0x%08x. Failure passed to caller.\n",
GetLastError());
}
}
CloseHandle(Overlapped.hEvent);
return Result;
}
//
// The following functions are wrappers around IoRecord, they just set the correct
// parameters in the IO_PARAM block to correspond to the requested operation and
// pass that to IoRecord.
//
BOOL ReadRecord(HANDLE hFile, ULONG RecNumber, PVOID Record, ULONG RecSize)
{
IO_PARAM IoParam;
IoParam.Type = IoRead;
IoParam.Params.IoInfo.Data = Record;
IoParam.Params.IoInfo.RecSize = RecSize;
return IoRecord(hFile, RecNumber, &IoParam);
}
BOOL WriteRecord(HANDLE hFile, ULONG RecNumber, PVOID Record, ULONG RecSize)
{
IO_PARAM IoParam;
IoParam.Type = IoWrite;
IoParam.Params.IoInfo.Data = Record;
IoParam.Params.IoInfo.RecSize = RecSize;
return IoRecord(hFile, RecNumber, &IoParam);
}
BOOL LockRecord(HANDLE hFile, ULONG RecNumber, BOOL Exclusive)
{
IO_PARAM IoParam;
IoParam.Type = IoLock;
IoParam.Params.LockInfo.Exclusive = Exclusive;
return IoRecord(hFile, RecNumber, &IoParam);
}
BOOL UnlockRecord(HANDLE hFile, ULONG RecNumber)
{
IO_PARAM IoParam;
IoParam.Type = IoUnlock;
return IoRecord(hFile, RecNumber, &IoParam);
}
ULONG ReserveFirstFreeRecord(BYTE* Bitmap)
//
// This function iterates through the bitmap and reserves the first free record
// it can find in the bitmap.
//
// Arguments:
// Bitmap - Pointer to the bitmap.
//
// Return value:
// Either zero, if there are no free records, or the position of the record
// that was just reserved.
//
{
int i;
BYTE Bit = 1;
for (i = 0; i < NUM_RECORDS; i++)
{
if (Bitmap[i / 8] & Bit)
{
Bit <<= 1;
if (Bit == 0) { Bit = 1; }
} else {
Bitmap[i / 8] |= Bit;
return i;
}
}
return 0;
}
BOOL TestBit(BYTE* Bitmap, ULONG Bit)
//
// This function tests if a given bit is set in the bitmap.
//
// Arguments:
// Bitmap - Pointer to the bitmap.
// Bit - Position of the bit in the bitmap.
//
// Return value:
// TRUE if the bit is set, FALSE otherwise.
//
{
ULONG Byte = Bit / 8;
Bit = Bit % 8;
return (BOOL)(Bitmap[Byte] & (1 << Bit));
}
void ClearBit(BYTE* Bitmap, ULONG Bit)
//
// This function clears a given bit in the bitmap.
//
// Arguments:
// Bitmap - Pointer to the bitmap.
// Bit - Position of the bit in the bitmap.
//
{
ULONG Byte = Bit / 8;
Bit = Bit % 8;
Bitmap[Byte] &= ~(1 << Bit);
}
#ifdef BRLS_DEBUG
void PrintBitmap(BYTE* Bitmap)
//
// This function prints the whole bitmap, for debugging purposes.
//
// Arguments:
// Bitmap - Pointer to the bitmap.
//
{
int i;
for (i = 0; i < BITMAP_SIZE; i++)
{
wprintf(L"%1x", Bitmap[i]);
}
wprintf(L"\n");
}
#endif
void InitRecord(RECORD_HEADER* Record, BOOL Master, ULONG SeqNumber)
//
// This function initializes a in-memory record structure with the correct
// type code and sequence number. In case of the Master Record, the bitmap
// is initialized too.
//
// Arguments:
// Record - Pointer to the record structure.
// Master - TRUE if this is a Master Record, FALSE otherwise.
// SeqNumber - Initial sequence number.
//
{
ULONG RecSize = Master ? sizeof(MASTER_RECORD) : sizeof(DATA_RECORD);
ULONG TypeCode = Master ? MASTER_RECORD_TYPE_CODE : DATA_RECORD_TYPE_CODE;
SecureZeroMemory(Record, RecSize);
Record->TypeCode = TypeCode;
Record->SeqNumber = Master ? 0 : SeqNumber;
if (Master)
{
((MASTER_RECORD*)Record)->Bitmap[0] = 1;
}
}
DATA_RECORD* PrepareRecord(ULONG SeqNumber)
//
// This function allocates a new in-memory record structure and initializes it
// as a brand new data record.
//
// Arguments:
// SeqNumber - Sequence number with which to initialize the record.
//
// Return value:
// Pointer to the record structure.
//
{
DATA_RECORD* Record = NULL;
Record = (DATA_RECORD*) malloc(sizeof(DATA_RECORD));
if (Record == NULL)
{
MSG_PRINTF(L"Critical error: malloc for CreateRecord failed.\n");
ErrorExitThread();
}
InitRecord((RECORD_HEADER*)Record, FALSE, SeqNumber);
return Record;
}
void WriteData(DATA_RECORD* Record)
//
// This function fills a in-memory data record structure with random data.
// Errors do not interrupt execution.
//
// Arguments:
// Record - Pointer to the record structure.
//
{
PUINT iData;
int i;
errno_t err;
iData = (PUINT)Record->Data;
for (i = 0; i < DATA_SIZE; i += sizeof(ULONG), iData++)
{
err = rand_s(iData);
if (err != 0)
{
MSG_PRINTF(L"rand_s for WriteData failed with error 0x%08x, continuing execution.\n",
err);
}
}
}
BOOL OperateOnRecord(HANDLE hFile, PULONG RecNumber, OPERATION Operation)
//
// This function executes a high-level operation in a record (create, modify or delete).
//
// Arguments:
// hFile - Handle to the file containing the record to be operated on.
// RecNumber - Pointer to a ULONG that either will receive the number of the
// record created by this operation or just contains the number
// of the record that will be modified or deleted.
// Operation - Operation to be performed (CreateRecord, ModifyRecord or
// DeleteRecord).
//
// Return value:
// TRUE if the operation succeeded, FALSE otherwise.
//
{
BOOL Result;
BOOL Exists;
BOOL ExclusiveLock;
MASTER_RECORD MasterRecord;
DATA_RECORD* Record;
// Fail operations on Master Record.
if ((Operation != CreateRecord) && (*RecNumber == 0))
{
MSG_PRINTF(L"Cannot operate on Master Record.\n");
return FALSE;
}
// Lock Master Record. If we're just modifying a record, we can get a
// shared lock.
ExclusiveLock = (Operation != ModifyRecord);
Result = LockRecord(hFile, 0, ExclusiveLock);
if (!Result)
{
MSG_PRINTF(L"LockRecord (MasterRecord) for OperateOnRecord failed with error 0x%08x.\n",
GetLastError());
ErrorExitThread();
}
// Read in Master Record.
Result = ReadRecord(hFile, 0, (PVOID)&MasterRecord, sizeof(MASTER_RECORD));
if (!Result)
{
MSG_PRINTF(L"ReadRecord (MasterRecord) for OperateOnRecord failed with error 0x%08x.\n",
GetLastError());
ErrorExitThread();
}
if (MasterRecord.Header.TypeCode != MASTER_RECORD_TYPE_CODE)
{
MSG_PRINTF(L"Master Record corruption error: wrong typecode!\n");
ErrorExitThread();
}
DBG_PRINTF(L"MasterRecord bitmap (before): ");
PrintBitmap(MasterRecord.Bitmap);
if (Operation != CreateRecord)
{
// Test the bit in the bitmap corresponding to this record.
Exists = TestBit(MasterRecord.Bitmap, *RecNumber);
// Clear the bit if we are deleting the record.
if ((Operation == DeleteRecord) && Exists)
{
ClearBit(MasterRecord.Bitmap, *RecNumber);
}
} else {
// Reserve the first free record.
*RecNumber = ReserveFirstFreeRecord(MasterRecord.Bitmap);
if (*RecNumber != 0)
{
Exists = TRUE;
} else {
Exists = FALSE;
MSG_PRINTF(L"File is full!\n");
}
}
DBG_PRINTF(L"MasterRecord bitmap (after): ");
PrintBitmap(MasterRecord.Bitmap);
if ((Operation != ModifyRecord) && Exists)
{
// Update the Master Record's sequence number.
MasterRecord.Header.SeqNumber++;
// Write Master Record down.
Result = WriteRecord(hFile, 0, (PVOID)&MasterRecord, sizeof(MASTER_RECORD));
if (!Result)
{
MSG_PRINTF(L"WriteRecord (MasterRecord) for CreateRecord failed with error 0x%08x.\n",
GetLastError());
ErrorExitThread();
}
}
// Unlock Master Record.
Result = UnlockRecord(hFile, 0);
if (!Result)
{
MSG_PRINTF(L"UnlockRecord (MasterRecord) for OperateOnRecord failed with error 0x%08x.\n",
GetLastError());
ErrorExitThread();
}
if (!Exists)
{
if (*RecNumber != 0)
{
MSG_PRINTF(L"Record %d not present!\n", *RecNumber);
}
return FALSE;
}
// For record deletion, processing is done and skip to write.
// Otherwise, there is more to do.
if (Operation != DeleteRecord)
{
// Prepare a new record in memory.
Record = PrepareRecord(1);
// Lock the record exclusively.
Result = LockRecord(hFile, *RecNumber, TRUE);
if (!Result)
{
MSG_PRINTF(L"LockRecord for ModifyRecord failed with error 0x%08x.\n",
GetLastError());
ErrorExitThread();
}
if (Operation == ModifyRecord)
{
// Read the record in from the file if we're modifying it.
Result = ReadRecord(hFile, *RecNumber, Record, RECORD_SIZE);
if (!Result)
{
MSG_PRINTF(L"ReadRecord for ModifyRecord failed with error 0x%08x.\n",
GetLastError());
ErrorExitThread();
}
// Update record sequence number.
Record->Header.SeqNumber++;
}
// Write to the in-memory record.
WriteData(Record);
// Write the record to the file.
Result = WriteRecord(hFile, *RecNumber, Record, RECORD_SIZE);
if (!Result)
{
MSG_PRINTF(L"WriteRecord for ModifyRecord failed with error 0x%08x.\n",
GetLastError());
ErrorExitThread();
}
// Unlock the record.
Result = UnlockRecord(hFile, *RecNumber);
if (!Result)
{
MSG_PRINTF(L"UnlockRecord for ModifyRecord failed with error 0x%08x.\n",
GetLastError());
ErrorExitThread();
}
// Free the record structure.
free(Record);
}
return TRUE;
}
ULONG RandomOption(ULONG NumOpts)
//
// This function returns a random number between 0 and (NumOpts - 1).
// It basically is a random option select.
//
// Arguments:
// NumOpts - Number of options to choose from.
//
// Return value:
// A random option (random ULONG x | 0 <= x < NumOpts).
//
{
UINT Random;
errno_t err;
err = rand_s(&Random);
if (err != 0)
{
MSG_PRINTF(L"rand_s for RandomOption failed with error 0x%08x\n",
err);
}
return Random % NumOpts;
}
DWORD WINAPI WorkerThread(PVOID data)
//
// This is the tight loop executed by each of the threads operating in the file.
// Each thread has its own handle to the same file. After obtaining that handle,
// they go into a tight loop in which a record number and a record operation are
// chosen at random and that operation is then performed in that record.
//
// Arguments:
// Data - PVOID to a string containing the file name (so it can be opened).
//
// Return value:
// It should not return.
//
{
HANDLE hFile;
LPCWSTR FileName = (LPCWSTR)data;
ULONG RecNumber;
OPERATION Operation;
BOOL Result;
UINT i;
hFile = CreateFile(FileName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
MSG_PRINTF(L"CreateFile failed with error 0x%08x.\n",
GetLastError());
ErrorExitThread();
}
// Main loop for doing the random operations.
for (i = 0; i < NUM_FILEOPS; i++)
{
RecNumber = RandomOption(NUM_RECORDS);
Operation = (OPERATION)RandomOption(MaxOprRecord);
// Output message as to what action is being attempted.
switch (Operation)
{
case CreateRecord:
MSG_PRINTF(L"attempting record creation.\n");
break;
case ModifyRecord:
MSG_PRINTF(L"attempting modification of record %d.\n", RecNumber);
break;
case DeleteRecord:
MSG_PRINTF(L"attempting deletion of record %d.\n", RecNumber);
break;
}
// Perform the actual operation and handle the result,
// then loop again until done.
Result = OperateOnRecord(hFile, &RecNumber, Operation);
if (Result)
{
switch (Operation)
{
case CreateRecord:
MSG_PRINTF(L"created record %d.\n", RecNumber);
break;
case ModifyRecord:
MSG_PRINTF(L"modified record %d.\n", RecNumber);
break;
case DeleteRecord:
MSG_PRINTF(L"deleted record %d.\n", RecNumber);
break;
}
}
}
CloseHandle(hFile);
MSG_PRINTF(L"%d file operations complete. Exiting thread.\n", i);
return 0;
}
BOOL InitNewFile(LPCWSTR FileName)
//
// This function initializes a file with records. If the file already exists, it
// just returns, assuming it has a valid Master Record on it. If it does not
// exist, a brand new file is created and initialized with a clean Master Record.
//
// Arguments:
// FileName - Name of the file to be initialized.
//
// Return value:
// TRUE if the initialization succeeded, FALSE otherwise.
//
{
HANDLE hFile;
MASTER_RECORD MasterRecord;
DWORD BytesWritten;
DWORD Result;
//
// Create the file or open existing.
//
hFile = CreateFile(FileName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (INVALID_HANDLE_VALUE == hFile)
{
MSG_PRINTF(L"CreateFile failed with error 0x%08x.\n",
GetLastError());
return FALSE;
}
else if (ERROR_ALREADY_EXISTS == GetLastError())
{
// This is ok, simply assume it's a valid file.
// Note that this does not actually test that the file
// is valid for this application. That error is caught later.
CloseHandle(hFile);
return TRUE;
} // The implied "else" is that the handle is a good one.
InitRecord((RECORD_HEADER*)&MasterRecord, TRUE, 0);
Result = WriteFile(hFile,
&MasterRecord,
sizeof(MASTER_RECORD),
&BytesWritten,
NULL);
if (!Result)
{
MSG_PRINTF(L"WriteFile failed with error 0x%08x.\n",
GetLastError());
}
CloseHandle(hFile);
return Result;
}
int __cdecl wmain(int argc, LPCWSTR argv[])
//
// Main function. Reads file name from command line argument, initializes the file
// and starts the worker threads, waiting for them to return.
//
{
HANDLE gThread[NUM_THREADS];
DWORD IdThread;
DWORD ResultCode;
LPCWSTR FileName = NULL;
if (argc != 2) {
wprintf(L"Invalid number of arguments!\n");
wprintf(L"Usage: %ws file_name\n", argv[0]);
return -1;
}
FileName = argv[1];
if (!InitNewFile(FileName))
{
wprintf(L"Unable to initialize the data file %ws.\n", FileName);
}
wprintf(L"Main thread creating %d worker threads for processing.\n",
NUM_THREADS);
for (int i = 0; i < NUM_THREADS; i++)
{
gThread[i] = CreateThread(NULL,
0,
(LPTHREAD_START_ROUTINE)WorkerThread,
(PVOID)FileName,
0,
&IdThread);
}
wprintf(L"Main thread waiting for worker threads to exit...\n");
ResultCode = WaitForMultipleObjects(
NUM_THREADS,
gThread,
TRUE,
INFINITE);
wprintf(L"WaitForMultipleObjects returned 0x%08x, execution complete.\n",
ResultCode);
// Do some clean-up.
for (int i = 0; i < NUM_THREADS; i++)
{
CloseHandle(gThread[i]);
}
return 0;
}
이 샘플은 파일에 대한 여러 동시 액세스를 실행하는 Windows 콘솔 애플리케이션으로, 모두 고정 크기의 여러 레코드로 구성된 간단한 데이터베이스를 사용하여 바이트 범위 잠금으로 조정됩니다. 진정한 동시성은 호스트 시스템에 존재하는 프로세서 코어 수에 따라 달라집니다.
모든 레코드에는 형식 코드와 시퀀스 번호라는 두 필드가 공통적으로 있습니다. 형식 코드는 두 가지 코드 중 하나입니다. "Mstr" 코드는 MASTER_RECORD 형식을 나타내고 "Data" 코드는 DATA_RECORD 형식을 나타냅니다. 하나의 MASTER_RECORD와 0개 이상의 DATA_RECORD가 있을 수 있습니다. 이 예제에서는 데이터 레코드에 포함된 데이터가 임의로 생성됩니다. 두 번째 필드인 시퀀스 번호는 레코드가 수정될 때마다 증분됩니다.
실행이 시작되면 데이터 파일이 아직 없는 경우 InitNewFile 함수에 의해 만들어지고 초기화됩니다. InitNewFile 함수는 시작 부분에 빈 비트맵이 있는 Master 형식의 레코드를 씁니다. 파일이 이미 있는 경우 파일이 열립니다. 처음에는 유효한 마스터 레코드가 있다고 가정합니다.
파일이 성공적으로 만들어지거나 성공적으로 열리면 여러 작업자 스레드가 시작되고 모두 작업과 레코드가 임의로 선택된 다음, 해당 레코드에서 해당 작업이 시도되는 루프를 실행합니다. 이러한 작업은 임의이므로 모든 작업이 성공하는 것은 아니지만 반드시 오류가 되는 것은 아닙니다. 적절한 상태 정보가 콘솔에 기록됩니다.
가능한 작업은 새 레코드 만들기, 기존 레코드 수정 또는 기존 레코드 삭제입니다. 만들기 작업은 비트맵을 확인하여 첫 번째 사용 가능한 레코드를 찾고 해당 레코드를 새 레코드로 할당합니다. 수정 작업은 비트맵을 읽어 해당 레코드가 실제로 존재하는지 확인하고, 있는 경우 해당 레코드를 수정합니다. 삭제 작업은 레코드에 해당하는 비트맵의 비트를 지우고 이후 할당을 위해 사용 중인 레코드 공간을 확보합니다. 또한 이러한 작업은 메타데이터가 저장되는 위치인 마스터 레코드에 대한 액세스 및 데이터 레코드 자체에 대한 액세스의 두 부분으로 분할됩니다.
데이터 레코드에 데이터를 쓰기 때문에 레코드 만들기 및 레코드 수정 작업은 데이터 레코드 액세스가 필요한 유일한 작업입니다. 이러한 이유로 레코드가 적용되는 지역은 작업이 수행되기 전에 배타적으로 잠깁니다. 만들기 및 삭제 작업은 비트맵을 수정하므로 마스터 레코드를 배타적으로 잠가야 합니다. 그러나 레코드 수정 작업은 파일이 있는지 확인하기 위해 쓰기가 아니라 비트맵을 읽기만 하면 됩니다. 이 작업의 경우 마스터 레코드에는 공유 바이트 범위 잠금만 필요합니다.
단독 바이트 범위 잠금은 파일에 대한 다른 모든 핸들의 읽기 및 쓰기 액세스를 모두 차단하며, 이것이 레코드에 쓸 때 사용되는 이유입니다. 반면에 공유 바이트 범위 잠금은 잠금을 소유하는 핸들을 포함하여 모든 핸들에서 쓰기 액세스를 차단하지만 모든 핸들에서 읽기 액세스를 허용합니다.
파일과 함께 바이트 범위 잠금을 사용하는 방법을 보여 주려면 새 파일 초기화를 제외한 이 샘플의 모든 I/O는 비동기 파일 핸들을 통해 수행됩니다. switch 문 내의 IoLock 및 IoUnlock case에서 IoRecord 함수에서 볼 수 있습니다. LockFileEx 및 UnlockFileEx 함수는 잠긴 범위의 시작에 대한 오프셋과 함께 OVERLAPPED 구조체를 전달하는 방식으로 겹치는 I/O 모델과 함께 사용되며, 함수가 즉시 반환되지 않는 한 해당 범위에 대한 잠금이 부여된 후 신호를 받을 이벤트입니다.
비동기 I/O 요청을 실행한 후 IoRecord 함수의 다음 작업은 인라인 작업을 기다리는 것입니다. 이것은 보통 최대 성능이 요구될 때 최적이 아닌 시나리오이지만 간단한 설명을 위해 여기에서 사용됩니다. 프로덕션 애플리케이션에서는 I/O 완료 포트 또는 유사한 메커니즘을 사용하는 것이 좋습니다. I/O가 완료되는 동안 다른 처리를 수행하는 스레드를 해제하기 때문입니다.
샘플은 NUM_FILEOPS 임의 작업을 실행한 후 종료됩니다. 각 스레드는 종료 상태를 오류 조건 또는 정상적인 종료로 기록합니다. 호스트 시스템의 프로세서 코어 수와 I/O 하위 시스템의 속도에 따라 모든 스레드가 동시에 종료되는 것은 아닙니다.