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 数组排序.
网友评论