How to have an event-loop on non-main thread in macOS?

Place Observers to the following Notifications below and let them invoke your methods. NotificationCenter are singleton for good reason, while you can of course, create your own. [NSWorkspace sharedWorkspace] is a singleton i guess, and [[NSWorkspace sharedWorkspace] notificationCenter] as named - the notification center to observe. The sending object to expect is nil in your case, because you don't know which object to observe more specific.

#import <AppKit/AppKit.h>

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
    // Insert code here to initialize your application
    [[[NSWorkspace sharedWorkspace] notificationCenter]
        addObserver:self
        selector:@selector(activeAppDidChange:)
        name:NSWorkspaceDidActivateApplicationNotification
        object:nil
    ];
    [[[NSWorkspace sharedWorkspace] notificationCenter]
        addObserver:self
        selector:@selector(activeAppDidTerminate:)
        name:NSWorkspaceDidTerminateApplicationNotification
        object:nil
    ];
    // id<NSObject> myObserver;
    _myObserver = [[[NSWorkspace sharedWorkspace] notificationCenter] 
        addObserverForName:NSWorkspaceDidHideApplicationNotification
        object:nil 
        queue:[NSOperationQueue mainQueue] 
        usingBlock:^(NSNotification * _Nonnull note) {
            // do stuff in block
            NSRunningApplication *app = note.userInfo[NSWorkspaceApplicationKey];
            NSLog(@"%u %@ %ld", 
               app.processIdentifier, 
               app.bundleIdentifier, 
               (long)app.activationPolicy
            );
        }
    ];
}
-(void)activeAppDidChange:(NSNotification *)note {
    NSLog(@"%@",note.userInfo.debugDescription);
}
-(void)activeAppDidTerminate:(NSNotification *)note {
    NSLog(@"%@",note.userInfo.debugDescription);
}

Just proof you can receive Notifications on Threads that are not mainThread.

// ThreadManagerExample.h
#import <AppKit/AppKit.h>
#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface ThreadManagerExample : NSObject
@property (nonatomic, readonly) BOOL started;
@property (nonatomic, readonly) uint64_t looptime;
-(void)start;
-(void)stop;
@end

NS_ASSUME_NONNULL_END

// ThreadManagerExample.m
#import "ThreadManagerExample.h"

static const double kThreadPriority = 1.0;

@interface ReceivingThread : NSThread
@property (nonatomic, weak) ThreadManagerExample * threadManager;
@end

@interface ThreadManagerExample ()
@property (nonatomic, strong) ReceivingThread *thread;
@property (nonatomic, readwrite) BOOL started;
@property (nonatomic, readwrite) uint64_t looptime;
@end

@implementation ThreadManagerExample
-(void)dealloc {
    [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(startThread) object:nil];
    if ( _thread ) {
        [_thread cancel];
        while ( !_thread.isFinished ) {
            [NSThread sleepForTimeInterval:0.01];
        }
    }
}
-(instancetype)init {
    if ( !(self = [super init]) ) return nil;
    _looptime = 1000000000; // 1 sec
    return self;
}

-(void)startThread {
    if ( !_thread) {
        self.thread = [ReceivingThread new];
        _thread.threadManager = self;
        _thread.name=@"ReceivingThread";
        [_thread setThreadPriority:kThreadPriority];
        [_thread start];
    }
}

-(void)start {
    if ( !_thread ) {
        @synchronized ( self ) {
            self.started = YES;
        }
        [self performSelector:@selector(startThread) withObject:nil afterDelay:0.0];
    }
}

-(void)stop {
    @synchronized ( self ) {
        self.started = NO;
    }
    if ( _thread ) {
        [_thread cancel];
        self.thread = nil;
    }
}
@end

@implementation ReceivingThread {
    BOOL somethinghappend;
    NSString *oldBundleIdentifier;
    NSString *lastbundleIdentifier;
    pid_t oldPID;
    pid_t focusedPID;
}
-(instancetype)init {
    if (!(self=[super init])) return nil;
    [[[NSWorkspace sharedWorkspace] notificationCenter] addObserver:self selector:@selector(mimi:) name:NSWorkspaceDidActivateApplicationNotification object:nil];
    return self;
}
-(void)mimi:(NSNotification*)note {
    NSRunningApplication *app = note.userInfo[NSWorkspaceApplicationKey];
    lastbundleIdentifier = app.bundleIdentifier;
    focusedPID = app.processIdentifier;
    if (![oldBundleIdentifier isEqualToString:lastbundleIdentifier]) {
        somethinghappend = YES;
    }
    oldBundleIdentifier = lastbundleIdentifier;
    oldPID = focusedPID;
}
-(void)main {
    [NSThread setThreadPriority:kThreadPriority];
    while ( !self.isCancelled ) {
        uint64_t nextLoop = 0;
        @synchronized ( _threadManager ) {
            if (somethinghappend) {
                NSLog(@"%@ %u",lastbundleIdentifier, focusedPID);
                somethinghappend = NO;
            }
            uint64_t now = mach_absolute_time();
            nextLoop = now + _threadManager.looptime;
        }
        mach_wait_until(nextLoop);
    }
}
@end

and instance and starting is done like..

if (!_manager) _manager = [[ThreadManagerExample alloc] init];
[_manager start];

stopping

[_manager stop];
_manager = nil; // if needed

So as looptime is set to 1 sec it will check each second if the last received bundleIdentifier was changed. You could extend the -(void)mimi: method by checking if the bundleIdentifier differs from [[NSBundle mainBundle] bundleIdentifier] to know if you became active yourself and ignore that when needed.

Edit from Apple Docs

NSRunningApplication is thread safe, in that its properties are returned atomically. However, it is still subject to the main run loop policy described above. If you access an instance of NSRunningApplication from a background thread, be aware that its time-varying properties may change from under you as the main run loop runs (or not).