The project setup and core code are based on a prior test framework. This version focuses on asynchronous, non-blocking thread-based IO execution and a responsive user interface.

1. Core Implementation

1> Async Thread IO Worker Logic

This method runs within spawned worker threads, executing IO operations and notifying the UI of completion directly.

unsigned CNonBlockingAsyncIO::ExecuteWorkerTask()
{
    int ioResult = PerformIO();
    
    // Map thread IDs to IO callers; array used for simplicity (STL map could improve efficiency)
    unsigned currentTid = GetCurrentThreadId();
    int arraySize = sizeof(m_threadIdList) / sizeof(m_threadIdList[0]);
    for (int idx = 0; idx < arraySize; idx++)
    {
        // Thread handles vary across contexts, so IDs are used for reliable caller-thread association
        if (currentTid == m_threadIdList[idx])
        {
            SendProgressUpdate(100, idx);
            SendResultNotification(ioResult, idx);
        }
    }
    
    return ioResult;
}

2> Start Operation Handler

This method launches worker threads without blocking the main UI thread, enabling immediate button state transition.

bool CNonBlockingAsyncIO::InitiateOperation()
{
    TerminateActiveThreads();
    int arraySize = sizeof(m_threadIdList) / sizeof(m_threadIdList[0]);
    for (int idx = 0; idx < arraySize; idx++)
    {
        HANDLE workerHandle = LaunchWorkerThread();
        m_threadHandleList[idx] = workerHandle;
        m_threadIdList[idx] = ::GetThreadId(workerHandle);
    }
    
    return true;
}

3> Stop Operation Handler

With non-blocking execution, the "Stop" button becomes functional. This implementation terminates active threads, though TerminateThread is used here as a simplified approach—Microsoft discourages this due to potential state corrupsion and unpredictable behavior.

bool CNonBlockingAsyncIO::TerminateActiveThreads()
{
    int arraySize = sizeof(m_threadHandleList) / sizeof(m_threadHandleList[0]);
    for (int idx = 0; idx < arraySize; idx++)
    {
        HANDLE activeHandle = m_threadHandleList[idx];
        if (activeHandle != NULL)
        {
            ForceThreadTerminationUntilExit(activeHandle);
            ::CloseHandle(activeHandle);
            m_threadHandleList[idx] = NULL;
        }
    }
    
    return true;
}

2. Test Results

Clicking "Start" immediately enables the "Stop" button and allows UI interactions like window movmeent, even while IO operations are ongoing. This asynchronous non-blocking pattern delivers excellent user responsiveness and simpler concurrency management compared to synchronous non-blocking designs. However, it introduces thread synchronization challenges when callbacks are used to update the UI thread, which must be careful addressed if the benefits of asynchrony do not outweigh the overhead of handling concurrency issues.