Alternative 1

#import <libkern/OSAtomic.h>

BOOL ale_dispatch_is_on_queue(dispatch_queue_t queue)
{
    int key;
    static int32_t incrementer;
    CFNumberRef value = CFBridgingRetain(@(OSAtomicIncrement32(&incrementer)));
    dispatch_queue_set_specific(queue, &key, value, nil);
    BOOL result = dispatch_get_specific(&key) == value;
    dispatch_queue_set_specific(queue, &key, nil, nil);
    CFRelease(value);
    return result;
}

Alternative 2

// *.h-file

@interface ALEQueue : NSObject

@property (nonatomic, strong, readonly) dispatch_queue_t queue;

- (instancetype)initWithQueue:(dispatch_queue_t)queue;
- (BOOL)isOnQueue;

@end

// *.m-file

#import <libkern/OSAtomic.h>

static int32_t _incrementer = 0;

@implementation ALEQueue {
    int _queueKey;
    CFNumberRef _value;
}

- (instancetype)initWithQueue:(dispatch_queue_t)queue
{
    ALEAssert(queue);
    
    self = [self init];
    if(self)
    {
        _value = CFBridgingRetain(@(OSAtomicIncrement32(&_incrementer)));
        _queue = queue;
        
        dispatch_queue_set_specific(queue, &_queueKey, _value, nil);
    }
    return self;
}

- (BOOL)isOnQueue
{
    CFStringRef value = dispatch_get_specific(&_queueKey);
    if(value == _value)
    {
        return YES;
    }
    return NO;
}

- (void)dealloc
{
    dispatch_queue_set_specific(_queue, &_queueKey, nil, nil);
    CFRelease(_value);
}

@end

Is this code okay? My unit tests pass, but is there any pitfalls I'm not seeing? Any performance considerations to make?

Should I prefer Alternative 2 since I'm only calling dispatch_queue_set_specific(...) twice and not each time I ask isOnQueue?

Or should I prefer Alternative 1 due to its simplicity?