美文网首页
NSOperation GUNStep源码

NSOperation GUNStep源码

作者: forping | 来源:发表于2020-11-16 13:46 被阅读0次

    gunstep foundation 代码下载
    NSOperation GUNStep源码
    NSInvocationOperation GUNStep源码
    NSOperationQueue GUNStep源码

    NSOperation

    首先是初始化方法

    - (id) init
    {
      if ((self = [super init]) != nil)
        {
          GS_CREATE_INTERNAL(NSOperation); // 创建_internal 成员变量宏,_internal是 NSOperationInternal 类型的
          internal->priority = NSOperationQueuePriorityNormal; // 默认优先级
          internal->threadPriority = 0.5; //线程优先级
          internal->ready = YES; // 是否准备好
          internal->lock = [NSRecursiveLock new]; // 初始化递归锁 
          [internal->lock setName:
            [NSString stringWithFormat: @"lock-for-opqueue-%p", self]];
          internal->cond = [[NSConditionLock alloc] initWithCondition: 0];// 初始化条件锁
          [internal->cond setName:
            [NSString stringWithFormat: @"cond-for-opqueue-%p", self]];
          [self addObserver: self
                 forKeyPath: @"isFinished"
                    options: NSKeyValueObservingOptionNew
                    context: isFinishedCtxt]; // 监听自己的完成状态
        }
      return self;
    }
    

    然后是dealloc函数

    - (void) dealloc
    {
      if (internal != nil)
        {
          NSOperation   *op;
    
          [self removeObserver: self forKeyPath: @"isFinished"]; // 移除监听完成
          while ((op = [internal->dependencies lastObject]) != nil)
        {
          [self removeDependency: op];// 移除依赖
        } 
          RELEASE(internal->dependencies);
          RELEASE(internal->cond);
          RELEASE(internal->lock);
          GS_DESTROY_INTERNAL(NSOperation);
        }
      [super dealloc];
    }
    

    main 方法

    - (void) main;
    {
      return;   // OSX default implementation does nothing
    }
    

    start 方法

    - (void) start
    {
      NSAutoreleasePool *pool = [NSAutoreleasePool new]; // 自动释放池
      double        prio = [NSThread  threadPriority]; // 线程的优先级
    
      AUTORELEASE(RETAIN(self));    // Make sure we exist while running.
      [internal->lock lock]; // 加锁
      NS_DURING // 异常处理
        {
          if (YES == [self isExecuting]) // 如果正在运行,抛出异常
        {
          [NSException raise: NSInvalidArgumentException
                  format: @"[%@-%@] called on executing operation",
            NSStringFromClass([self class]), NSStringFromSelector(_cmd)];
        }
          if (YES == [self isFinished]) // 如果完成,抛出异常
        {
          [NSException raise: NSInvalidArgumentException
                  format: @"[%@-%@] called on finished operation",
            NSStringFromClass([self class]), NSStringFromSelector(_cmd)];
        }
          if (NO == [self isReady]) // 如果没有准备就绪,抛出异常
        {
          [NSException raise: NSInvalidArgumentException
                  format: @"[%@-%@] called on operation which is not ready",
            NSStringFromClass([self class]), NSStringFromSelector(_cmd)];
        }
          if (NO == internal->executing) //  修改为正在运行,
        {
          [self willChangeValueForKey: @"isExecuting"];
          internal->executing = YES;
          [self didChangeValueForKey: @"isExecuting"];
        }
        }
      NS_HANDLER
        {
          [internal->lock unlock];
          [localException raise];
        }
      NS_ENDHANDLER
      [internal->lock unlock]; // 解锁
    
      NS_DURING
        {
          if (NO == [self isCancelled])
        {
          [NSThread setThreadPriority: internal->threadPriority]; // 设置线程优先级,然后执行main函数
          [self main];
        }
        }
      NS_HANDLER
        {
          [NSThread setThreadPriority:  prio];
          [localException raise];
        }
      NS_ENDHANDLER;
    
      [self _finish]; // 
      [pool release];
    }
    

    _finlish 方法

    - (void) _finish
    {
      /* retain while finishing so that we don't get deallocated when our
       * queue removes and releases us.
       */
      [self retain];
      [internal->lock lock]; // 加锁
      if (NO == internal->finished) 
        {
          if (YES == internal->executing) // 如果正在执行, 改为finlish
            {
          [self willChangeValueForKey: @"isExecuting"];
          [self willChangeValueForKey: @"isFinished"];
          internal->executing = NO;
          internal->finished = YES;
          [self didChangeValueForKey: @"isFinished"];
          [self didChangeValueForKey: @"isExecuting"];
        }
          else // 否则直接改为finlish
        {
          [self willChangeValueForKey: @"isFinished"];
          internal->finished = YES;
          [self didChangeValueForKey: @"isFinished"];
        }
          if (NULL != internal->completionBlock)
        { // 当前线程 回调block
          CALL_BLOCK_NO_ARGS(internal->completionBlock); 
        }
        }
      [internal->lock unlock];
      [self release];
    }
    

    添加依赖

    - (void) addDependency: (NSOperation *)op // 添加依赖
    {
    // 异常判定
      if (NO == [op isKindOfClass: [NSOperation class]])
        {
          [NSException raise: NSInvalidArgumentException
              format: @"[%@-%@] dependency is not an NSOperation",
        NSStringFromClass([self class]), NSStringFromSelector(_cmd)];
        }
      if (op == self)
        {
          [NSException raise: NSInvalidArgumentException
              format: @"[%@-%@] attempt to add dependency on self",
        NSStringFromClass([self class]), NSStringFromSelector(_cmd)];
        }
    //加锁
      [internal->lock lock];
      if (internal->dependencies == nil)
        {
          internal->dependencies = [[NSMutableArray alloc] initWithCapacity: 5]; // 创建依赖数组
        }
    
      NS_DURING
        {
          if (NSNotFound == [internal->dependencies indexOfObjectIdenticalTo: op]) // 判断是否已经有依赖了
        {
          [self willChangeValueForKey: @"dependencies"];
              [internal->dependencies addObject: op]; // 添加依赖
          /* We only need to watch for changes if it's possible for them to
           * happen and make a difference.
           */
          if (NO == [op isFinished]
            && NO == [self isCancelled]
            && NO == [self isExecuting]
            && NO == [self isFinished]) // 如果依赖的操作还没有完成,或者自己还没执行/取消
            {
              /* Can change readiness if we are neither cancelled nor
               * executing nor finished.  So we need to observe for the
               * finish of the dependency.
               */
              [op addObserver: self
               forKeyPath: @"isFinished"
                  options: NSKeyValueObservingOptionNew
                  context: isFinishedCtxt]; // 监听依赖的完成情况
              if (internal->ready == YES) // 如果自己已经准备就绪了,取消准备就绪
            {
              /* The new dependency stops us being ready ...
               * change state.
               */
              [self willChangeValueForKey: @"isReady"];
              internal->ready = NO; // 没有准备好
              [self didChangeValueForKey: @"isReady"];
            }
            }
          [self didChangeValueForKey: @"dependencies"];
        }
        }
      NS_HANDLER // 处理异常
        {
          [internal->lock unlock];
          NSLog(@"Problem adding dependency: %@", localException);
          return;
        }
      NS_ENDHANDLER
      [internal->lock unlock];
    }
    

    kvo的回调

    - (void) observeValueForKeyPath: (NSString *)keyPath
                   ofObject: (id)object
                             change: (NSDictionary *)change
                            context: (void *)context
    {
      [internal->lock lock];
    
      /* We only observe isFinished changes, and we can remove self as an
       * observer once we know the operation has finished since it can never
       * become unfinished.
       */
        // 已经完成了就不监听了
      [object removeObserver: self forKeyPath: @"isFinished"];
    
      if (object == self)
        { // 如果是自己完成了
          /* We have finished and need to unlock the condition lock so that
           * any waiting thread can continue.
           */
          [internal->cond lock];
          [internal->cond unlockWithCondition: 1];
          [internal->lock unlock];
          return;
        }
    
      if (NO == internal->ready) // 如果自己还没准备好, 判断所有的依赖,如果没有依赖了,就修改自己的状态
        {
          NSEnumerator  *en;
          NSOperation   *op;
    
          /* Some dependency has finished (or been removed) ...
           * so we need to check to see if we are now ready unless we know we are.
           * This is protected by locks so that an update due to an observed
           * change in one thread won't interrupt anything in another thread.
           */
          en = [internal->dependencies objectEnumerator]; // 获得依赖
          while ((op = [en nextObject]) != nil)
            {
              if (NO == [op isFinished])
            break;
            }
          if (op == nil)
        {
              [self willChangeValueForKey: @"isReady"];
          internal->ready = YES; // 准备好
              [self didChangeValueForKey: @"isReady"];
        }
        }
      [internal->lock unlock];
    }
    

    移除依赖

    - (void) removeDependency: (NSOperation *)op
    {
      [internal->lock lock];
      NS_DURING
        {
          if (NSNotFound != [internal->dependencies indexOfObjectIdenticalTo: op]) // 如果依赖关系存在
        {
          [op removeObserver: self forKeyPath: @"isFinished"]; // 移除对依赖的finlish的监听
          [self willChangeValueForKey: @"dependencies"];
          [internal->dependencies removeObject: op]; // 移除依赖
          if (NO == internal->ready) // 如果自己是没准备好的状态
            {
              /* The dependency may cause us to become ready ...
               * fake an observation so we can deal with that.
               */
              [self observeValueForKeyPath: @"isFinished"
                      ofObject: op
                        change: nil
                       context: isFinishedCtxt]; // 手动触发一次kvo回调,认为依赖操作已经完成
            }
          [self didChangeValueForKey: @"dependencies"];
        }
        }
      NS_HANDLER
        {
          [internal->lock unlock];
          NSLog(@"Problem removing dependency: %@", localException);
          return;
        }
      NS_ENDHANDLER
      [internal->lock unlock];
    }
    

    返回依赖

    - (NSArray *) dependencies
    {
      NSArray   *a;
    
      if (internal->dependencies == nil)
        {
          a = empty;    // OSX return an empty array, 静态的空数组
        }
      else
        {
          [internal->lock lock];
          a = [NSArray arrayWithArray: internal->dependencies];
          [internal->lock unlock];
        }
      return a;
    }
    

    cancel方法

    - (void) cancel
    {
      if (NO == internal->cancelled && NO == [self isFinished]) // 判断条件
        {
          [internal->lock lock];
          if (NO == internal->cancelled && NO == [self isFinished]) // 加锁后再判断一下
        {
          NS_DURING
            { 设置自己的状态
              [self willChangeValueForKey: @"isCancelled"];
              internal->cancelled = YES;
              if (NO == internal->ready)
            {
                  [self willChangeValueForKey: @"isReady"];
              internal->ready = YES;
                  [self didChangeValueForKey: @"isReady"];
            }
              [self didChangeValueForKey: @"isCancelled"];
            }
          NS_HANDLER
            {
              [internal->lock unlock];
              NSLog(@"Problem cancelling operation: %@", localException);
              return;
            }
          NS_ENDHANDLER
        }
          [internal->lock unlock];
        }
    }
    

    等待直到完成:就是一个条件锁, 初始条件设置为0, 只有当自己的任务完成时,条件设置为1 ,这个代码才会执行完成,

    - (void) waitUntilFinished
    {
      [internal->cond lockWhenCondition: 1];    // Wait for finish
      [internal->cond unlockWithCondition: 1];  // Signal any other watchers
    }
    

    简单总结: 以上就是NSOperation的主要代码, 没有涉及到创建线程的概念,执行的时候会调用start方法,start方法里面修改状态,并调用main方法. 如果要继承,只需要重写main方法即可

    NSOperaion的 queuePriority 属性用于 NSOperationQueue waiting 数组排序.

    相关文章

      网友评论

          本文标题:NSOperation GUNStep源码

          本文链接:https://www.haomeiwen.com/subject/enpabktx.html