Обмен данными между процессами через файлы, что отображаются в памяти

#include <iostream>
#include <memory>
#include <list>
using namespace std;
 
#include <windows.h>
 
namespace
{
    template <typename T>
    class Thread
    {
    public:
        Thread()
            : Thread_(NULL)
        {
        }
        ~Thread()
        {
            Stop();
        }
        void Run(T* functor)// запуск потока
        {
            if (Thread_)
                throw exception("Thread is run");
            DWORD ThreadId = 0;
            if (!(Thread_ = ::CreateThread(NULL, 0, &Thread::ThreadProc, functor, 0, &ThreadId)))
                throw exception("Can't create thread");
        }
        void Stop(bool wait = true)
        {
            if (!Thread_)
                return;
            if (wait)
                ::WaitForSingleObject(Thread_, INFINITE);//останавливает выполнения программы
                                                         //до тех пор пока объект , идентификатор которого передан в функцию
                                                         //не окажется в "сигнальном" состоянии
                                                         //вместо указания конкретного времени в милисекундах
                                                         //можно просто передать "строковую" константу = INFINITE
            else
                ::TerminateThread(Thread_, 0);
            ::CloseHandle(Thread_);
        }
    private:
        HANDLE Thread_;
        static DWORD WINAPI ThreadProc(LPVOID prm)
        {
            (*reinterpret_cast<T*>(prm))();
            return 0;
        }
        Thread(const Thread&);
        Thread& operator = (const Thread&);
    };
}
    struct Job
    {
        virtual ~Job()
        {
        }
        void Release()
        {
            delete this;
        }
        virtual void* Get() = 0;
    };
 
    template <typename T>
    class JobImpl : public Job
    {
    public:
        JobImpl(T* data)
            : Data(data)
        {
        }
        void* Get()
        {
            return Data.get();
        }
    private:
        auto_ptr<T> Data;
    };
 
    class CriticalSection
    {
    public:
        CriticalSection()//участок исполняемого кода программы,
                         //в котором производится доступ к общему ресурсу,
                         //который не должен быть одновременно использован более чем одним потоком выполнения.
        {
            ::InitializeCriticalSection(&Section);//в ситуации нехватки памяти
        }
        ~CriticalSection()
        {
            ::DeleteCriticalSection(&Section);
        }
        void Enter()
        {
            ::EnterCriticalSection(&Section);//блокирует до тех пор, пока поток не сможет взять в монопольное использование критическую секцию.
        }
        void Leave()
        {
            ::LeaveCriticalSection(&Section); //поток входит в критическую секцию
        }
    private:
        CRITICAL_SECTION Section;
        CriticalSection(const CriticalSection&);
        CriticalSection& operator = (const CriticalSection&);
    };
 
    template <typename T>
    class Locker//блокировка на запись
    {
    public:
        Locker(T& synObj)
            : SynObj(synObj)
        {
            SynObj.Enter();
        }
        ~Locker()
        {
            SynObj.Leave();
        }
    private:
        Locker(const Locker&);
        Locker& operator = (const Locker&);
        T& SynObj;
    };
 
    class JobList
    {
    public:
        JobList()
        {
        }
        ~JobList()
        {
            Clear();
        }
        void Clear()
        {
            Locker<CriticalSection> Locl(Section);
            for (list<Job*>::iterator i = Jobs.begin(); i != Jobs.end(); ++i)
                try
            {
                (*i)->Release();
            }
            catch (...)
            {
            }
            Jobs.clear();
        }
        void Add(Job* job)
        {
            Locker<CriticalSection> Locl(Section);
            Jobs.push_back(job);
        }
        Job* Get()
        {
            Locker<CriticalSection> Locl(Section);
            Job* Result = 0;
            if (!Jobs.empty())
            {
                Result = Jobs.front();
                Jobs.pop_front();
            }
            return Result;
        }
    private:
        CriticalSection Section;
        list<Job*> Jobs;
        JobList(const JobList&);
        JobList& operator = (const JobList&);
    };
 
    class Event//синхронизация
    {
    public:
        Event()
            : Event_(NULL)
        {
            if (!(Event_ = ::CreateEvent(NULL, FALSE, FALSE, NULL)))
                throw exception("Can't create event");
        }
        ~Event()
        {
            ::CloseHandle(Event_);
        }
        void Enter()
        {
            ::WaitForSingleObject(Event_, INFINITE);
        }
        void Leave()
        {
            ::SetEvent(Event_);
        }
    private:
        Event(const Event&);
        Event& operator = (const Event&);
        HANDLE Event_;
    };
 
    class Writer
    {
    public:
        Writer(JobList& list, Event& event, int count)
            : List(list)
            , Count(count)
            , Event_(event)
        {
        }
        void operator () ()
        {
            for (int i = Count; i >= 0; --i)
            {
                List.Add(new JobImpl<int>(new int(i)));
                Event_.Leave();
                if (!(i % 5)) // Спим после каждых 5 заданий :)
                    ::Sleep(100);
            }
        }
    private:
        JobList& List;
        Event& Event_;
        int Count;
    };
 
    class Reader
    {
    public:
        Reader(JobList& list, Event& event)
            : List(list)
            , Event_(event)
        {
        }
        void operator () ()
        {
            while (true)
            {
                Job* CurJob = List.Get();
                if (!CurJob)
                {
                    Event_.Enter();
                    continue;
                }
                int Data = *reinterpret_cast<int*>(CurJob->Get());
                CurJob->Release();
                cout << Data << endl;
                if (!Data)
                    break;
            }
        }
    private:
        JobList& List;
        Event& Event_;
    };
 
    class Sample
    {
    public:
        Sample()
            : Writer_(List, Event_, 50)
            , Reader_(List, Event_)
            , Writer2_(List, Event_, 50)
            , Reader2_(List, Event_)
        {
            WriterThread.Run(&Writer_);
            ReaderThread.Run(&Reader_);
            WriterThread2.Run(&Writer2_);
            ReaderThread2.Run(&Reader2_);
        }
    private:
        JobList List;
        Event Event_;
        Writer Writer_;
        Thread<Writer> WriterThread;
        Reader Reader_;
        Thread<Reader> ReaderThread;
 
        Writer Writer2_;
        Thread<Writer> WriterThread2;
        Reader Reader2_;
        Thread<Reader> ReaderThread2;
 
    };
 
void main()
{
    try
    {
        Sample();
    }
    catch (exception& err)
    {
        cerr << err.what() << endl;
    }
    system("pause");
}
 
 
 
ConsoleApp:
 
#include "pch.h"
#include <windows.h>
#include <stdio.h>
#include <conio.h>
 
// Идентификаторы объектов-событий, которые используются
// для синхронизации задач, принадлежащих разным процессам
HANDLE hEvent;
HANDLE hEventTermination;
 
// Имя объекта-события для синхронизации ввода и отображения
wchar_t lpEventName[] = L"$MyVerySpecialEventName$";
 
// Имя объекта-события для завершения процесса
wchar_t lpEventTerminationName[] =
L"$MyVerySpecialEventTerminationName$";
 
// Имя отображния файла на память
wchar_t lpFileShareName[] =
L"$MyVerySpecialFileShareName$";
 
// Идентификатор отображения файла на память
HANDLE hFileMapping;
 
// Указатель на отображенную область памяти
LPVOID lpFileMap;
 
int main()
{
    CHAR chr;
 
    printf("Mapped and shared file, client process\n");
 
    // Открываем объект-событие для синхронизации 
    // ввода и отображения
    hEvent = OpenEvent(EVENT_ALL_ACCESS, FALSE, lpEventName);
 
    if (hEvent == NULL)
    {
        fprintf(stdout, "OpenEvent: Error %ld\n",
            GetLastError());
        _getch();
        return 0;
    }
 
    // Открываем объект-событие для сигнализации о
    // завершении процесса ввода
    hEventTermination = OpenEvent(EVENT_ALL_ACCESS,FALSE, lpEventTerminationName);
 
    if (hEventTermination == NULL)
    {
        fprintf(stdout, "OpenEvent (Termination): Error %ld\n",
            GetLastError());
        _getch();
        return 0;
    }
 
    // Открываем объект-отображение
    hFileMapping = OpenFileMapping(FILE_MAP_READ | FILE_MAP_WRITE, FALSE, lpFileShareName);
 
    // Если открыть не удалось, выводим код ошибки
    if (hFileMapping == NULL)
    {
        fprintf(stdout, "OpenFileMapping: Error %ld\n",
            GetLastError());
        _getch();
        return 0;
    }
 
    // Выполняем отображение файла на память.
    // В переменную lpFileMap будет записан указатель на
    // отображаемую область памяти
    lpFileMap = MapViewOfFile(hFileMapping, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
 
    // Если выполнить отображение не удалось,
    // выводим код ошибки
    if (lpFileMap == 0)
    {
        fprintf(stdout, "MapViewOfFile: Error %ld\n",
            GetLastError());
        _getch();
        return 0;
    }
 
    // Цикл ввода. Этот цикл завершает свою работу,
    // когда пользователь нажимает клавишу <ESC>, 
    // имеющую код 27
    while (TRUE)
    {
        // Проверяем код введенной клавиши
        chr = _getche();
 
        // Если нажали клавишу <ESC>, прерываем цикл
        if (chr == 27)
            break;
 
        // Записываем символ в отображенную память,
        // доступную серверному процессу
        *((LPSTR)lpFileMap) = chr;
 
        // Устанавливаем объект-событие в отмеченное
        // состояние
        SetEvent(hEvent);
    }
 
    // После завершения цикла переключаем оба события
    // в отмеченное состояние для отмены ожидания в
    // процессе отображения и для завершения этого процесса
    SetEvent(hEvent);
    SetEvent(hEventTermination);
 
    // Закрываем идентификаторы объектов-событий
    CloseHandle(hEvent);
    CloseHandle(hEventTermination);
 
    // Отменяем отображение файла
    UnmapViewOfFile(lpFileMap);
 
    // Освобождаем идентификатор созданного
    // объекта-отображения
    CloseHandle(hFileMapping);
    return 0;
}
 
 
 
Проект: 
 
 
 
#include <windows.h>
#include <stdio.h>
#include <conio.h>
 
// Идентификаторы объектов-событий, которые используются
// для синхронизации задач, принадлежащих разным процессам
HANDLE hEventChar;
HANDLE hEventTermination;
HANDLE hEvents[2];
 
// Имя объекта-события для синхронизации ввода и отображения
CHAR lpEventName[] =
"$MyVerySpecialEventName$";
 
// Имя объекта-события для завершения процесса
CHAR lpEventTerminationName[] =
"$MyVerySpecialEventTerminationName$";
 
// Имя отображния файла на память
CHAR lpFileShareName[] =
"$MyVerySpecialFileShareName$";
 
// Идентификатор отображения файла на память
HANDLE hFileMapping;
 
// Указатель на отображенную область памяти
LPVOID lpFileMap;
 
int main()
{
    DWORD dwRetCode;
 
    printf("Mapped and shared file, server process\n");
 
    // Создаем объект-событие для синхронизации 
    // ввода и отображения, выполняемого в разных процессах
    hEventChar = CreateEvent(NULL, FALSE, FALSE, lpEventName);
 
    // Если произошла ошибка, получаем и отображаем ее код,
    // а затем завершаем работу приложения
    if (hEventChar == NULL)
    {
        fprintf(stdout, "CreateEvent: Error %ld\n",
            GetLastError());
        _getch();
        return 0;
    }
 
    // Если объект-событие с указанным именем существует,
    // считаем, что приложение EVENT уже было запущено
    if (GetLastError() == ERROR_ALREADY_EXISTS)
    {
        printf("\nApplication EVENT already started\n"
            "Press any key to exit...");
        _getch();
        return 0;
    }
 
    // Создаем объект-событие для определения момента
    // завершения работы процесса ввода
    hEventTermination = CreateEvent(NULL, FALSE, FALSE, lpEventTerminationName);
 
    if (hEventTermination == NULL)
    {
        fprintf(stdout, "CreateEvent (Termination): Error %ld\n",
            GetLastError());
        _getch();
        return 0;
    }
 
    // Создаем объект-отображение
    hFileMapping = CreateFileMapping((HANDLE)0xFFFFFFFF, NULL, PAGE_READWRITE, 0, 100, lpFileShareName);
 
    // Если создать не удалось, выводим код ошибки
    if (hFileMapping == NULL)
    {
        fprintf(stdout, "CreateFileMapping: Error %ld\n",
            GetLastError());
        _getch();
        return 0;
    }
 
    // Выполняем отображение файла на память.
    // В переменную lpFileMap будет записан указатель на
    // отображаемую область памяти
    lpFileMap = MapViewOfFile(hFileMapping, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
 
    // Если выполнить отображение не удалось,
    // выводим код ошибки
    if (lpFileMap == 0)
    {
        fprintf(stdout, "MapViewOfFile: Error %ld\n",
            GetLastError());
        _getch();
        return 0;
    }
 
    // Готовим массив идентификаторов событий
    // для функции WaitForMultipleObjects
    hEvents[0] = hEventTermination;
    hEvents[1] = hEventChar;
 
    // Цикл отображения. Этот цикл завершает свою работу
    // при завершении процесса ввода
    while (TRUE)
    {
        // Выполняем ожидание одного из двух событий:
        //   - завершение клиентского процесса;
        //   - завершение ввода символа
        dwRetCode = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE);
 
        // Если ожидание любого из двух событий было отменено,
        // если произошло первое событие (завершение клиентского
        // процесса) или если произошла ошибка, прерываем цикл
        if (dwRetCode == WAIT_ABANDONED_0 ||
            dwRetCode == WAIT_ABANDONED_0 + 1 ||
            dwRetCode == WAIT_OBJECT_0 ||
            dwRetCode == WAIT_FAILED)
            break;
 
        // Читаем символ из первого байта отображенной
        // области памяти, записанный туда клиентским 
        // процессом, и отображаем его в консольном окне
        _putch(*((LPSTR)lpFileMap));
    }
 
    // Закрываем идентификаторы объектов-событий  
    CloseHandle(hEventChar);
    CloseHandle(hEventTermination);
 
    // Отменяем отображение файла
    UnmapViewOfFile(lpFileMap);
 
    // Освобождаем идентификатор созданного
    // объекта-отображения
    CloseHandle(hFileMapping);
 
    return 0;
}