코딩시러

CreatePipe 함수(namedpipeapi.h) - Win32 apps | Microsoft Learn

익명 파이프 생성 예시

#include <iostream>
#include <Windows.h>

int main()
{
    HANDLE hRead, hWrite;

    // 이 예제는 부모-자식 프로세스에 대한 구분이 없으므로 실제로 사용할 땐, CreateProcess로 부모 프로세스가 자식 프로세스를 생성해야한다.
    // 익명 파이프 생성
    if (CreatePipe(&hRead, &hWrite, NULL, 0))
    {
        std::cout << "익명 파이프 생성 성공" << '\n';
    }
    else
    {
        std::cerr << "익명 파이프 생성 실패" << '\n';
        return 1;
    }

    // 쓰기 쓰레드: 데이터를 파이프에 쓰기
    const char* data = "Hello, Anonymous Pipe!";
    DWORD bytesWritten;

    if (WriteFile(hWrite, data, strlen(data) + 1, &bytesWritten, NULL))
    {
        std::cout << "파이프에 데이터 쓰기 성공: " << bytesWritten << " 바이트" << '\n';
    }
    else
    {
        std::cerr << "파이프 쓰기 실패" << '\n';
    }

    // 읽기 쓰레드: 데이터를 파이프에서 읽기
    char buffer[128] = { 0 };
    DWORD bytesRead;

    if (ReadFile(hRead, buffer, sizeof(buffer) - 1, &bytesRead, NULL))
    {
        std::cout << "파이프에서 데이터 읽기 성공: " << buffer << '\n';
    }
    else
    {
        std::cerr << "파이프 읽기 실패" << '\n';
    }

    // 커널 객체 반납
    CloseHandle(hRead);
    CloseHandle(hWrite);

    return 0;
}

CreateNamedPipeA 함수(winbase.h) - Win32 apps | Microsoft Learn

네임드 파이프 생성 예시 (읽기, 쓰기는 없음)

#include "pch.h"
#include <iostream>

int main()
{
	return 0;
	HANDLE hPipe = CreateNamedPipe(
		L"\\.\pipe\MyPipe",			 // 파이프 이름(\\.\pipe\의 뒤에 이름)
		PIPE_ACCESS_DUPLEX,          // 양방향 통신
		PIPE_TYPE_BYTE | PIPE_WAIT,  // 바이트 스트림과 동기식 통신
		1,                           // 인스턴스 개수
		512, 512,                    // 출력/입력 버퍼 크기
		0,                           // 기본 타임아웃
		NULL                         // 보안 속성
	);
	CloseHandle(hPipe);
	return 0;
}

C-C++ 코드 예제: 큐 만들기 | 마이크로소프트 런

명명된 공유 메모리 만들기 - Win32 apps | Microsoft Learn

쓰기

#include <windows.h>
#include <iostream>

// 쓰는 프로세스
int main() 
{
    // 공유 메모리 생성
    HANDLE hMapFile = CreateFileMapping(
        INVALID_HANDLE_VALUE,          // 물리적 파일이 아닌 메모리 사용
        nullptr,                       // 기본 보안 속성
        PAGE_READWRITE,                // 읽기/쓰기 가능
        0,                             // 고위 메모리 크기 (사용 안 함)
        256,                           // 공유 메모리 크기 (256 바이트)
        L"SharedMemoryExample");       // 공유 메모리 이름

    // 공유 메모리 매핑
    LPVOID pBuf = MapViewOfFile(
        hMapFile,                      // 메모리 매핑 핸들
        FILE_MAP_ALL_ACCESS,           // 읽기/쓰기 액세스
        0, 0, 0);                      // 전체 영역 매핑

    // 데이터 쓰기
    const char* message = "Hello!";
    CopyMemory(pBuf, message, strlen(message) + 1);
    Sleep(5000);
    UnmapViewOfFile(pBuf);
    CloseHandle(hMapFile);

    return 0;
}

읽기

#include <windows.h>
#include <iostream>

// 읽는 프로세스
int main() 
{
    Sleep(1000);
    // 공유 메모리 열기
    HANDLE hMapFile = OpenFileMapping(
        FILE_MAP_ALL_ACCESS,           // 읽기/쓰기 액세스
        FALSE,                         // 자식 프로세스 상속 여부 (아니오)
        L"SharedMemoryExample");       // 공유 메모리 이름 (생성 시와 동일해야 함)

    // 공유 메모리 매핑
    LPVOID pBuf = MapViewOfFile(
        hMapFile,                      // 메모리 매핑 핸들
        FILE_MAP_ALL_ACCESS,           // 읽기/쓰기 액세스
        0, 0, 0);

    // 데이터 읽기
    std::cout << "공유 메모리에서 데이터를 읽었습니다: " << static_cast<char*>(pBuf) << std::endl;

    UnmapViewOfFile(pBuf);
    CloseHandle(hMapFile);
}

socket 함수(winsock2.h) - Win32 apps | Microsoft Learn

소켓 서버/클라이언트 예시 코드

*서버

#include<iostream>
#include<string>
#include<winsock2.h>
#pragma comment(lib, "ws2_32.lib")

#define PORT 6060
#define BUFFER_SIZE 100

SOCKET gListen, gAccept;
SOCKADDR_IN gAddress;
CHAR buffer[BUFFER_SIZE] = { 0 };

// 서버
int main()
{
    // 윈속 초기화
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
    {
        printf("socket() failed with error %d\n", WSAGetLastError());
        return -1;
    }

    if ((gListen = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
    {
        printf("socket() failed with error %d\n", WSAGetLastError());
        return -1;
    }

    gAddress.sin_family = AF_INET;
    gAddress.sin_addr.s_addr = INADDR_ANY;
    gAddress.sin_port = htons(PORT);

    // 소켓 바인딩
    if (bind(gListen, (PSOCKADDR)&gAddress, sizeof(gAddress)) == SOCKET_ERROR)
    {
        printf("bind() failed with error %d\n", WSAGetLastError());
        return -1;
    }

    // 연결 요청 수신 대기
    if (listen(gListen, 5))
    {
        printf("listen() failed with error %d\n", WSAGetLastError());
        return -1;
    }

    std::cout << "Waiting for a connection..." << std::endl;

    // 연결 수락
    if ((gAccept = accept(gListen, NULL, NULL)) == INVALID_SOCKET)
    {
        printf("accept() failed with error %d\n", WSAGetLastError());
        return -1;
    }

    std::cout << "Connection!" << std::endl;

    // 받기
    if (recv(gAccept, buffer, sizeof(buffer), 0) <= 0)
    {
        printf("WSARecv() failed with error %d\n", WSAGetLastError());
        return -1;
    }
    std::cout << "Message received: " << buffer << std::endl;

    // 종료
    closesocket(gListen);
    closesocket(gAccept);
    WSACleanup();
    return 0;
}

*클라이언트

#include<iostream>
#include<string> 
#include<WinSock2.h> 
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib")

#define PORT 6060
#define ADDR "127.0.0.1"
#define BUFFER_SIZE 100

SOCKET gSocket;
SOCKADDR_IN gAddress;
CHAR buffer[BUFFER_SIZE] = {0};

// 클라
int main()
{
    Sleep(1000);
    // 윈속 초기화
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
    {
        printf("socket() failed with error %d\n", WSAGetLastError());
        return -1;
    }
    gAddress.sin_family = AF_INET;
    gAddress.sin_port = htons(PORT);

    if (inet_pton(AF_INET, ADDR, &(gAddress.sin_addr)) != 1)
    {
        printf("Invalid IP address %d\n", WSAGetLastError());
        return -1;
    }
    else
    {
        std::cout << "Server IP address: " << ADDR << std::endl;
        if ((gSocket = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
        {
            printf("socket() failed with error %d\n", WSAGetLastError());
            return -1;
        }
        if (connect(gSocket, (SOCKADDR*)&gAddress, sizeof(gAddress)) < 0)
        {
            printf("connect() failed with error %d\n", WSAGetLastError());
            return -1;
        }
        std::cout << "Connected to server!" << std::endl;
        std::string sendMessage;

        std::cout << "Input massge: ";
        std::cin >> sendMessage;

        /* 5. 메시지 전송 */

        send(gSocket, sendMessage.c_str(), sendMessage.length(), 0);

        closesocket(gSocket);
    }
    WSACleanup();
    return 0;
}

CreateFileMappingA 함수(winbase.h) - Win32 apps | Microsoft Learn

MapViewOfFile 함수(memoryapi.h) - Win32 apps | Microsoft Learn

메모리 맵 사용 예시

#include <iostream>
#include <windows.h>

#define FILE_PATH "example.txt"
#define BUFFER_SIZE 256

int main() {
    // 파일 열기(없으면 생성)
    HANDLE hFile = CreateFileA(
        FILE_PATH,                       // 파일 경로
        GENERIC_READ | GENERIC_WRITE,    // 읽기/쓰기 권한
        0,                               // 공유 모드 없음
        NULL,                            // 보안 속성
        OPEN_ALWAYS,                     // 파일이 없으면 생성
        FILE_ATTRIBUTE_NORMAL,           // 일반 파일 속성
        NULL                             // 템플릿 파일 없음
    );

    if (hFile == INVALID_HANDLE_VALUE) {
        std::cerr << "CreateFile failed: " << GetLastError() << std::endl;
        return -1;
    }

    // 파일 매핑 생성
    HANDLE hMapFile = CreateFileMappingA(
        hFile,                // 파일 핸들
        NULL,                 // 보안 속성
        PAGE_READWRITE,       // 읽기/쓰기 권한
        0,                    // 파일 크기 상위 32비트
        BUFFER_SIZE,          // 파일 크기 하위 32비트
        NULL                  // 이름 없음
    );

    if (hMapFile == NULL) {
        std::cerr << "CreateFileMapping failed: " << GetLastError() << std::endl;
        CloseHandle(hFile);
        return -1;
    }

    // 매핑된 메모리 접근
    LPVOID pBuf = MapViewOfFile(
        hMapFile,               // 메모리 매핑 핸들
        FILE_MAP_ALL_ACCESS,    // 접근 권한
        0,                      // 오프셋 상위 32비트
        0,                      // 오프셋 하위 32비트
        BUFFER_SIZE             // 매핑 크기
    );

    if (pBuf == NULL) {
        std::cerr << "MapViewOfFile failed: " << GetLastError() << std::endl;
        CloseHandle(hMapFile);
        CloseHandle(hFile);
        return -1;
    }

    // 데이터 쓰기
    strcpy_s((char*)pBuf, BUFFER_SIZE, "Hello, File Mapping!");

    std::cout << "Data written to file via mapping: " << (char*)pBuf << std::endl;

    // 메모리 해제
    UnmapViewOfFile(pBuf);
    CloseHandle(hMapFile);
    CloseHandle(hFile);

    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mutex1, mutex2;

void Worker1() 
{
    mutex1.lock();
    std::this_thread::sleep_for(std::chrono::milliseconds(100));  // 다른 스레드가 실행될 여유를 줌
    mutex2.lock();

    mutex1.unlock();
    mutex2.unlock();
}

void Worker2() 
{
    mutex2.lock();
    std::this_thread::sleep_for(std::chrono::milliseconds(100));  // 다른 스레드가 실행될 여유를 줌
    mutex1.lock();

    mutex2.unlock();
    mutex1.unlock();
}

int main() {
    std::thread t1(Worker1);
    std::thread t2(Worker2);

    t1.join();
    t2.join();

    return 0;
}

이렇게 되면 worker1은 mutex1을 통해 임계영역에 접근을 했지만, mutex2를 통해 또 다른 자원에 접근하고 싶지만, 이미 worker2가 mutex2를 통해 해당 자원을 점유한 상태입니다.
(따라서 초딩같이 싸우고 있다는거임ㅋㅋ)

직접 써봐야 더 이해가 잘 될거같아서 해보았읍니다.

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>

std::vector<int> q;
std::mutex mtx;

// 이 매크로를 끄면 뮤텍스를 안씁니다.
#define USE_MUTEX

void UseMutexWorker(int id)
{
	mtx.lock(); // 뮤텍스 획득

	// TODO : 작업 실시
	q.push_back(id);
	std::cout << "Thread ID " << id << " - push_back()\n";
	// 작업 종료

	mtx.unlock(); // 뮤텍스 해제
}

void DefaultWorker(int id)
{
	q.push_back(id);
	std::cout << "Thread ID " << id << " - push_back()\n";
}

int main()
{
	std::vector<std::thread> workers;
	for (int i = 0; i < 10; ++i)
	{
#ifdef USE_MUTEX
		workers.push_back(std::thread(UseMutexWorker, i));
#else
		workers.push_back(std::thread(DefaultWorker, i));
#endif // USE_MUTEX
	}
	for (int i = 0; i < workers.size(); ++i)
	{
		// 스레드가 종료되었는가?
		workers[i].join();
	}
	for (int i = 0; i < q.size(); ++i)
	{
		std::cout << "Queue[" << i << "] = " << "Thread ID " <<  q[i] << " Visit\n";
	}
}

스레드에게 ID값을 0~9까지 만들고, 각 스레드들은 전역변수의 큐에 자신의 ID값을 넣는 간단한 코드입니다.

변화를 보기 위해 #define USE_MUTEX 을 사용해 뮤텍스를 쓰는 코드와 안쓰는 코드를 스레드에게 넘겨줬습니다.

1. 뮤텍스를 안쓴 경우

뮤텍스를 쓰지 않으면 큐에 넣는 작업의 순서도 뒤죽박죽이며, 간헐적으로 크래시가 난다. 동시 접근에 대한 에러로 인해 나는 크래시인듯 하다.

2. 뮤텍스를 쓴 경우

뮤텍스를 쓰면 깔끔해지는 모습이다. 근데 사실 이러면 싱글스레드를 쓴거나 다름없다. 오히려 싱글스레드보다 느리다.

직접 써봐야 더 이해가 잘 될거같아서 해보았읍니다.

#include <iostream>
#include <windows.h>
#include <thread>
#include <vector>

#define MAX_WORK 3   // 동시에 실행할 수 있는 최대 스레드 수
#define TOTAL_TASKS 10  // 작업 총 개수

std::vector<int> q;
HANDLE semaphore;  // 세마포어 핸들

// 이 매크로를 끄면 세마포어를 안씁니다.
//#define USE_SEMAPHORE

void UseSemaphoreWorker(int id)
{
    // 세마포어 대기 (카운트가 0이면 대기 상태)
    WaitForSingleObject(semaphore, INFINITE);

    // 작업 시작
    q.push_back(id);
    std::cout << "Thread ID " << id << " - push_back()\n";

    // 세마포어 해제 (카운트 증가)
    ReleaseSemaphore(semaphore, 1, NULL);
}

void DefaultWorker(int id)
{
    q.push_back(id);
    std::cout << "Thread ID " << id << " - push_back()\n";
}


int main() 
{
    // 세마포어 생성
    semaphore = CreateSemaphore(
        NULL,             // 보안 속성
        MAX_WORK,         // 초기 카운트
        MAX_WORK,         // 최대 카운트
        NULL              // 세마포어 이름 (익명)
    );

    std::vector<std::thread> workers;

    for (int i = 0; i < TOTAL_TASKS; ++i) 
    {
#ifdef USE_SEMAPHORE
        workers.push_back(std::thread(UseSemaphoreWorker, i));
#else
        workers.push_back(std::thread(DefaultWorker, i));
#endif // USE_MUTEX
    }

    // 모든 스레드가 종료될 때까지 대기
    for (auto& t : workers) { t.join(); }

    for (int i = 0; i < q.size(); ++i)
    {
        std::cout << "Queue[" << i << "] = " << "Thread ID " << q[i] << " Visit\n";
    }

    // 세마포어 닫기
    CloseHandle(semaphore);

    return 0;
}

위 뮤텍스 코드와 동작은 같습니다. 다만 세마포어 객체를 만들어 동기화 관리를 한다는 점에서 다릅니다.

위 코드에선 최대 3개의 스레드가 동시에 일할 수 있도록 설정해놓았습니다.

세마포어를 안쓴 경우는 위 뮤텍스 코드랑 다를게 없어서 넘어가겠습니다.

- 세마포어를 쓴 결과

엄 사실 짜고보니까 예시가 세마포어를 써야하는 상황이랑 안맞는 것 같습니다.

어쨋든 동작은 최대 3개의 스레드가 동시에 일하도록 만든 코드입니다...