Can I use PostMessage() like this?

I am currently working on an MFC project, which runs several threads and uses PostMessage() for the message exchange between the worker thread and the Main UI thread.

I wrote a code like below:

UINT ThreadFunc (LPVOID pParam) {
    pointerToMainUI->PostMessage(WM_EXAMPLE, MSG_EXAMPLE_1, 1);    
    pointerToMainUI->PostMessage(WM_EXAMPLE, MSG_EXAMPLE_2, 2); // Question 1
}

void MyDialogExClass::OnBnClickedStart() {
    int intA = 0; // Declared in header as public global

    mThreadA = AfxBeginThread(ThreadFunc , this);
    mThreadB = AfxBeginThread(ThreadFunc , this); // Question 2
}

LRESULT MyDialogExClass::WinProc (WPARAM wParam, LPARAM lParam) {
    
    int iParam = (int)lParam;

    switch (wParam) {
    case MSG_EXAMPLE_1:
        intA = iParam;
        break;

    case MSG_EXAMPLE_2:
        // Do Something
        break;
    }
    
    return LRESULT();
}

It is important for my application to do FIFO, which had me wonder if my data and memory is at any risk.

My Question:

1. Is it safe for me to have the thread do two PostMessage() calls in a row?

2. Is it safe for me to have two different threads running that will change the value of a variable from the main thread?

1. In this case, yes. Your posted values are fully contained inside the lParam of the messages, so there is no cross-threading issue to post them. If you were posting pointers to values, that would be a different story.

2. In this case, yes. You are not updating the variable directly in your threads, you are delegating the values to the main UI thread, and then it is updating the variable. The messages will be processed one at a time, and the message queue will ensure they are processed in the order that they are posted.

Yes what you are doing is ok, except updating using global variables.
Here is an example using std::thread and lambda functions

void MyDialogExClass::~MyDialogExClass()
{
    // ensure threads are finished before Dialog is fully destructed.
    // or you might have a race condition.
    m_ThreadA.join();
    m_ThreadB.join();
}

void MyDialogExClass::OnBnClickedStart() 
{
    // Todo : Add some threadsafe logic to avoid click from running while
    // threads are still busy

    // avoid globals!
    // int intA = 0; // Declared in header as public global

    // Do NOT use winapi to start threads
    // it is really cumbersome to pass data to callbacks etc.
    // mThreadA = AfxBeginThread(ThreadFunc, this);
    // mThreadB = AfxBeginThread(ThreadFunc, this); // Question 2

    // use lambda expression to call member functions, or functions using member variables
    // [&] will capture `this` by reference
    // threads will be members of the dialog (you can also use std::async and std::future)
    // std::thread m_ThreadA;
    // std::thread m_ThreadB; 
    mThreadA = std::thread([&] { PostMessage(WM_EXMPLE, MSG_EAMPLE_1, 1); } );
    mThreadB = std::thread([&] { PostMessage(WM_EXMPLE, MSG_EAMPLE_1, 1); });
}

LRESULT MyDialogExClass::WinProc(WPARAM wParam, LPARAM lParam) {

    int iParam = (int)lParam;

    switch (wParam) {
    case MSG_EXAMPLE_1:
        // intA = iParam; Do NOT use globals (specialy not in multithreaded env)
        break;

    case MSG_EXAMPLE_2:
        // Do Something
        break;
    }

    return LRESULT{};
}