同步线程和进程间的通信

最近回去学习了一下进程和进程间的通信，有时候很多东西久不看了也就一下子忘了==

这里面有好几个互斥对象使用线程的

void mListText(CString str)
{
    m_list_text.AddString(str);
    m_list_text.SendMessage(WM_VSCROLL, SB_PAGEDOWN, 0);
}



DWORD WINAPI Thread1(LPVOID lpParameter)
{
    //GetDlgItem(IDC_STATIC_THREAD)
    //SetDlgItemText(NULL, IDC_STATIC_THREAD, L"Thread1 is running");
    //CString str1 = L"Thread1 is running";
    //C线程Dlg test;
    //test.m_list_text.AddString(str1);
    //SetDlgItemText(test, IDC_STATIC_THREAD, L"Thread1 is running");
    //AfxMessageBox(L"Thread1 is running");
    CString str2 = L"Thread1 is running";
    m_list_text.AddString(str2);
    //Sleep(1000);
    //mListText(str2);
    return 0;
}

DWORD WINAPI Thread2(LPVOID lpParameter)
{
    //GetDlgItem(IDC_STATIC_THREAD)
    CString str2 = L"Thread2 is running";
    m_list_text.AddString(str2);
    //Sleep(1000);
    //mListText(str2);
    //test.m_list_text.AddString(str2);
    //SetDlgItemText( IDC_STATIC_THREAD, L"Thread2 is running");
    //AfxMessageBox(L"Thread2 is running");
    return 0;
}


//线程，不同步的
void C线程Dlg::OnStatThread()
{
    // TODO:  在此添加控件通知处理程序代码
    //SetDlgItemText( IDC_STATIC_THREAD,L"Thread2 is running");
    HANDLE T1, T2;
    int i = 0;
    while (i != 5)
    {
        T1 = CreateThread(NULL, 0, Thread1, NULL, 0, NULL);
        T2 = CreateThread(NULL, 0, Thread2, NULL, 0, NULL);
        Sleep(1000);
        i++;
    }
    CloseHandle(T1);
    CloseHandle(T2);
}

//线程3,线程4 使用InitializeCriticalSection（）来操作临界对象
DWORD WINAPI Thread3(LPVOID lpParameter)
{
    C线程Dlg test;
    while (true)
    {
        EnterCriticalSection(&Section);   //进入临界区
        a1++;
        if (a1 <= 10)
        {
            Sleep(1000);
            CString str;
            str.Format(L"Thread3 is running,count=%d", a1);
            //AfxMessageBox(str);
            mListText(str);
            LeaveCriticalSection(&Section);   //离开临界区
        }
        else
        {
            LeaveCriticalSection(&Section);
            break;
        }
    }
    return 0;
}

//线程4
DWORD WINAPI Thread4(LPVOID lpParameter)
{
    C线程Dlg dlg;
    while (true)
    {
        EnterCriticalSection(&Section);   //进入临界区
        a1++;
        if (a1 <=10)
        {
            Sleep(1000);
            CString str;
            str.Format(L"Thread4 is running,count=%d", a1);
            mListText(str);
            //AfxMessageBox(str);
            //AfxMessageBox(L"Thread4 is running");
            LeaveCriticalSection(&Section);   //离开临界区
        }
        else
        {
            LeaveCriticalSection(&Section);
            break;
        }
    }
    return 0;
}

//同步线程
void C线程Dlg::OnSynchronous()
{
    // TODO:  在此添加控件通知处理程序代码
    HANDLE T3, T4;
    T3 = CreateThread(NULL, 0, Thread3, NULL, 0, NULL);
    T4 = CreateThread(NULL, 0, Thread4, NULL, 0, NULL);

    CloseHandle(T3);
    CloseHandle(T4);
    
    //初始化临界区
    InitializeCriticalSection(&Section);
    if (a1 == 10)
    {
        DeleteCriticalSection(&Section); //删除临界区
    }
}

//线程5，线程6使用CCriticalSection操作临界区
DWORD WINAPI Thread5(LPVOID lpvoid)
{
    m_Section.Lock();   //对临界区锁定
    a1++;
    CString str;
    str.Format(L"Thread5 is running,count=%d", a1);
    mListText(str);
    //AfxMessageBox(str);
    m_Section.Unlock();  //解锁，释放临界区
    return 0;
}

DWORD WINAPI Thread6(LPVOID lpvoid)
{
    m_Section.Lock();   //对临界区锁定
    a1++;
    CString str;
    str.Format(L"Thread6 is running,count=%d", a1);
    //AfxMessageBox(str);
    mListText(str);
    m_Section.Unlock();  //解锁，释放临界区

    return 0;
}



void C线程Dlg::OnCCriticalSectionThread()
{
    // TODO:  在此添加控件通知处理程序代码
    HANDLE T5, T6;
    T5 = CreateThread(NULL, 0, Thread5, NULL, 0, NULL);
    T6 = CreateThread(NULL, 0, Thread6, NULL, 0, NULL);
    CloseHandle(T5);
    CloseHandle(T6);
    Sleep(3000);
}


void C线程Dlg::ListText(CString str)
{
    m_list_text.AddString(str);
    m_list_text.SendMessage(WM_VSCROLL, SB_PAGEDOWN, 0);
}



void C线程Dlg::OnMListClear()
{
    // TODO:  在此添加控件通知处理程序代码
        
        m_list_text.DeleteString(0);

    
    
    //m_list_text.DeleteTempMap();
}

由于之前测试的时候m_list_text.AddString()不是一个个显示的，所以在控制台下测试了一下，如下

#include<windows.h>
#include<iostream>
HANDLE hevent;   //设置事件对象
HANDLE hmutex;   //第二种方法，设置互斥事件对象
//CEvent event; 也可以用CEvent事件来操作，步骤和HANDLE差不多

int a=0;  

//用事件操作临界区步骤：
//创建事件对象-->初始化时设置为无信号-->设置为有信号
//在线程中:等待事件-->设置为无信号事件-->进行操作-->设置为有信号事件
DWORD WINAPI Thread7(LPVOID lpParemt)
{
    while (true)
    {

        WaitForSingleObject(hevent, INFINITE);  //无限等待请求事件
        ResetEvent(hevent);  //设置为无信号事件
        Sleep(100);
        if (a < 20)
        {
            a++;
            std::cout << "Thread7 is running and count= " << a << std::endl;
            SetEvent(hevent);
        }
        else
        {
            SetEvent(hevent);
            break;
        }
    }
    return 0;
}
DWORD WINAPI Thread8(LPVOID lpParemt)
{
    while (true)
    {

        WaitForSingleObject(hevent, INFINITE);  //无限等待请求事件
        ResetEvent(hevent);  //设置为无信号事件
        Sleep(100);
        if (a < 20)
        {
            a++;
            std::cout << "Thread8 is running and count= " << a << std::endl;
            SetEvent(hevent);
        }
        else
        {
            SetEvent(hevent);
            break;
        }
    }
    return 0;
}

//线程9，10 使用互斥事件使线程同步
DWORD WINAPI Thread9(LPVOID lpParemt)
{
    while (true)
    {
        WaitForSingleObject(hmutex, INFINITE);   //请求互斥对象
        if (a < 20)
        {
            a++;
            Sleep(100);
            std::cout << "mutex thread9 is running and the count=" << a << std::endl;
            ReleaseMutex(hmutex);
        }
        else
        {
            break;
        }
    }
    return 0;
}

DWORD WINAPI Thread10(LPVOID lpParemt)
{
    while (true)
    {
        WaitForSingleObject(hmutex, INFINITE);   //请求互斥对象
        if (a < 20)
        {
            a++;
            Sleep(100);
            std::cout << "mutex thread10 is running and the count=" << a << std::endl;
            ReleaseMutex(hmutex);
        }
        else
        {
            break;
        }
    }
    return 0;
}


int main()
{
    HANDLE H1, H2;
    hevent = CreateEvent(NULL, false, false, NULL);    //无信号的自动重置事件，第二个参数设置事件自动还是手动，第三是有无信号参数
    SetEvent(hevent);    //设置为有信号事件
    H1 = CreateThread(NULL, 0, Thread7, NULL, 0, NULL);
    H2 = CreateThread(NULL, 0, Thread8, NULL, 0, NULL);
    CloseHandle(H1);
    CloseHandle(H2);
    Sleep(3000);

    //使用互斥事件
    a = 0;
    HANDLE H3, H4;
    hmutex = CreateMutex(NULL, FALSE, NULL);   //设置对象为未能取得事件所有权
    H3 = CreateThread(NULL, 0, Thread9, NULL, 0, NULL);
    H4 = CreateThread(NULL, 0, Thread10, NULL, 0, NULL);
    CloseHandle(H3);
    CloseHandle(H4);
    Sleep(3000);

    //进程间的通信


    return 0;
}

运行结果如下：

进程间的通信（邮慒通信）

服务端

#include<iostream>
#include<windows.h>
int main()
{
    HANDLE mail;
    mail = CreateMailslot(L"\\.\mailslot\mysolt", 0, MAILSLOT_WAIT_FOREVER, NULL);
    if (mail == INVALID_HANDLE_VALUE)
    {
        std::cout << "创建邮慒失败" << std::endl;
        CloseHandle(mail);
    }
    else
    {
        std::cout << "创建邮慒成功" << std::endl;
        char text[100];
        std::string str;
        DWORD readtext;
        while (true)
        {

            if (ReadFile(mail, text, 100, &readtext, 0))
            {
                std::cout << text << std::endl;
            }
            else
            {
                std::cout << "读取数据失败" << std::endl;
            }
        }
    }
    CloseHandle(mail);
    Sleep(2000);
    return 0;
}

客户端

#include<iostream>
#include<windows.h>
int main()
{
    HANDLE mail;
    char text[] = "just a test";
    DWORD wirtetext;
    mail = CreateFile(L"\\.\mailslot\mysolt", GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (mail == INVALID_HANDLE_VALUE)
    {
        std::cout << "邮慒打开失败" << std::endl;
    }
    else
    {
        while (true)
        {
            std::cout << "write data" << std::endl;
            std::cin >> text;
            //std::cin.getline(text);
            if (WriteFile(mail, text, sizeof(text), &wirtetext, NULL))
            {
                std::cout << "邮慒写入数据成功" << std::endl;
            }
            else
            {
                std::cout << "邮慒写入数据失败" << std::endl;
            }
        }
    }
    Sleep(1000);
    return 0;
}