Create a global mutex, to identify if another instance of the same application is running, this is needed as its inter process communication

Richard is so right!!, you might take a project away from someone else that understands the code or have more experience than yourself, causing them harm. That been said, here is examples in C# and C++...

Using C#

using System;
using System.Threading;

class Program {
    static Mutex mutex = new Mutex(true, "MyAppName");

    static void Main() {
        if (mutex.WaitOne(TimeSpan.Zero, true)) {
            try {
                // Run the application
            } finally {
                mutex.ReleaseMutex();
            }
        } else {
            // Another instance of the application is already running
        }
    }
}

This creates a Mutex object that can be used to ensure that only one instance of the application can run at a time. The first parameter passed to the Mutex constructor is a Boolean value that indicates whether the calling thread should initially own the mutex. The second parameter is a string that is used to identify the mutex. If another instance of the application is already running and has created a mutex with the same name, the WaitOne method will return false, indicating that another instance of the application is already running.

You can use this mechanism to ensure that only one instance of your application is running at a time, and to prevent the user from accidentally starting multiple instances of the application.

Using C++

#include <windows.h>

int main() {
    HANDLE hMutex = CreateMutex(NULL, TRUE, L"MyAppName");
    if (GetLastError() == ERROR_ALREADY_EXISTS) {
        // Another instance of the application is already running
        CloseHandle(hMutex);
        return 1;
    }

    // Run the application

    ReleaseMutex(hMutex);
    CloseHandle(hMutex);
    return 0;
}

This creates a global mutex with the name "MyAppName" using the CreateMutex function. The first parameter is a pointer to a security attributes structure, which can be set to NULL. The second parameter is a Boolean value that indicates whether the calling thread should initially own the mutex. The third parameter is a string that is used to identify the mutex.

If another instance of the application is already running and has created a mutex with the same name, the GetLastError() function will return ERROR_ALREADY_EXISTS, indicating that another instance of the application is already running.

You can use this mechanism to ensure that only one instance of your application is running at a time, and to prevent the user from accidentally starting multiple instances of the application.

Note: Make sure to include the windows.h header file for the CreateMutex and ReleaseMutex functions.

A C++ std::mutex instance is limited to a single process; if you need cross-process mutexes, as here, you could use operating system semaphores or, under Linux, Posix mutexes in shared memory.
If the first process sets a system-wide mutex semaphore to 0, the second process could execute a sem_wait() on that semaphore and would be blocked until the mutex is removed. The command line arguments are processed before the sem_wait() and could thus send a message to the first process via IPC. If one uses non-blocking messages no threading is necessary.
If one of the processes receives the "Stop" command it could send a message to the first command and would be blocked by the mutex first. Once the first process gets the message it would have to unblock the mutex before it exits. Then the next process in the mutex queue would continue.
If you use blocking messages you would need a thread so that the output can happen every second.

// edit:
Several IPC mechanisms can be used for cross-process non-blocking data exchange. Semaphores are not suitable for this, since the value of the semaphore would have to be accessed unsynchronized. In principle, it would be possible to use shared memory, nonblocking pipes or messages. Since here an unknown number of processes can communicate with each other a solution with Shared Memory would be probably a good choice, since one must know here neither source nor destination and besides all at the same time bidirectional access have. However, access should also be secured with a mutex for this very reason.

Here are a few sources in the Windows context:
https://learn.microsoft.com/en-us/windows/win32/memory/sharing-files-and-memory
https://learn.microsoft.com/en-us/windows/win32/ipc/synchronous-and-overlapped-input-and-output
https://learn.microsoft.com/en-us/windows/win32/ipc/reading-from-a-mailslot

Example: Creating Named Shared Memory (Windows):
https://learn.microsoft.com/en-us/windows/win32/memory/creating-named-shared-memory

The C++ source code for Windows might look like this at the beginning:

HANDLE hMutexApp = CreateMutex( NULL, FALSE, TEXT("MyMutexApp"));
HANDLE hMutexShm = CreateMutex( NULL, FALSE, TEXT("MyMutexShm"));

HANDLE hMapFile;
const DWORD BUF_SIZE = 256;
TCHAR szName[] = TEXT("Global\\MyFileMappingObject");

hMapFile = CreateFileMapping(
	INVALID_HANDLE_VALUE,    // use paging file
	NULL,                    // default security
	PAGE_READWRITE,          // read/write access
	0,                       // maximum object size (high-order DWORD)
	BUF_SIZE,                // maximum object size (low-order DWORD)
	szName);                 // name of mapping object

// map object to pointer
LPCTSTR pBuf = (LPTSTR)MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, BUF_SIZE);

Alternatively, a solution with threading and only semaphores would probably be possible here. The whole thing works similarly under Linux, only that the system calls differ.