iOS开发 使用异步Operation

OC代码

#import "ConcurrentOperation.h"
@interface ConcurrentOperation(){
    BOOL        executing;
    BOOL        finished;
}
@property (nonatomic, copy)NSString *cusName;
@end
@implementation ConcurrentOperation
- (id)init {
    self = [super init];
    if (self) {
        executing = NO;
        finished = NO;
    }
    return self;
}
 
- (instancetype)initWithName:(NSString *)name {
    self = [super init];
    if (self) {
        executing = NO;
        finished = NO;
        _cusName = name;
        
    }
    return self;
}
 
//- (BOOL)isConcurrent {
//    return YES;
//}
 
- (BOOL)isAsynchronous {
    return YES;
}
 
- (BOOL)isExecuting {
    return executing;
}
 
- (BOOL)isFinished {
    return finished;
}
 
- (void)start {
    // Always check for cancellation before launching the task.
    NSLog(@"%@----start-----------------", _cusName);
    if ([self isCancelled])
    {
        // Must move the operation to the finished state if it is canceled.
        [self willChangeValueForKey:@"isFinished"];
        finished = YES;
        [self didChangeValueForKey:@"isFinished"];
        return;
    }
    
    // If the operation is not canceled, begin executing the task.
    [self willChangeValueForKey:@"isExecuting"];
    [NSThread detachNewThreadSelector:@selector(main) toTarget:self withObject:nil];
    executing = YES;
    [self didChangeValueForKey:@"isExecuting"];
}
 
- (void)main {
    @try {
        
        // Do the main work of the operation here.
        NSInteger i = 1000;
        while (i--) {
           NSLog(@"%@----main---", _cusName);
        }
        [self completeOperation];
    }
    @catch(...) {
        // Do not rethrow exceptions.
    }
}
 
- (void)completeOperation {
    [self willChangeValueForKey:@"isFinished"];
    [self willChangeValueForKey:@"isExecuting"];
    
    executing = NO;
    finished = YES;
    
    [self didChangeValueForKey:@"isExecuting"];
    [self didChangeValueForKey:@"isFinished"];
}

Swift

import Foundation

class ConcurrentOperation: Operation {
    
    private enum ModifyState: String{
        case isExecuting = "isExecuting"
        case isFinished = "isFinished"
    }
    
    private var cusName:String?
    
    init(cusName: String? = nil) {
        self.cusName = cusName
    }
    
    private var _executing:Bool = false{
        willSet{
            willChangeValue(forKey: ModifyState.isExecuting.rawValue)
        }
        didSet{
            didChangeValue(forKey: ModifyState.isExecuting.rawValue)
        }
    }

    private var _finished:Bool = false{
        willSet{
            willChangeValue(forKey: ModifyState.isFinished.rawValue)
        }
        didSet{
            didChangeValue(forKey: ModifyState.isFinished.rawValue)
        }
    }
    
    override var isExecuting: Bool{
        return _executing
    }
    override var isFinished: Bool{
        return _finished
    }
    override var isAsynchronous: Bool{
        return true
    }
    
    
    override func start() {
        if isCancelled{
            _finished = true
            return
        }
        _executing = true
        
        DispatchQueue.global().async {
            self.main()
        }
//        Thread.detachNewThreadSelector(#selector(main), toTarget: self, with: nil)
    }
    
    override func main() {
        var i = 100000;
        while i > 0 {
            print("\(cusName ?? "")+\(i)")
            i-=1
        }
        
        completeOperation();
    }
    
    private func completeOperation() {
        _executing = false
        _finished = true
    }
}