我知道这是一个旧的，但即使我发现自己又一次徘徊在它旁边，所以我想在这里提交我自己的选择。

最好的办法是看看我的博客文章: 在Objective-C中计时:秒表

基本上，我写了一个类，它以非常基本的方式停止观看，但被封装，所以你只需要做以下事情:

[MMStopwatchARC start:@"My Timer"];
// your work here ...
[MMStopwatchARC stop:@"My Timer"];

最后你会得到:

MyApp[4090:15203]  -> Stopwatch: [My Timer] runtime: [0.029]

在日志里…

再一次，看看我的帖子，或者在这里下载: MMStopwatch.zip

struct TIME {

    static var ti = mach_timebase_info()
    static var k: Double = 1
    static var mach_stamp: Double {

        if ti.denom == 0 {
            mach_timebase_info(&ti)
            k = Double(ti.numer) / Double(ti.denom) * 1e-6
        }
        return Double(mach_absolute_time()) * k
    }
    static var stamp: Double { return NSDate.timeIntervalSinceReferenceDate() * 1000 }
}

do {
    let mach_start = TIME.mach_stamp
    usleep(200000)
    let mach_diff = TIME.mach_stamp - mach_start

    let start = TIME.stamp
    usleep(200000)
    let diff = TIME.stamp - start

    print(mach_diff, diff)
}

好吧，如果你的目标是找出你可以修复什么使它更快，那是一个有点不同的目标。测量函数所花费的时间是一种很好的方法，可以发现您所做的事情是否产生了影响，但要找出该做什么，您需要一种不同的技术。这就是我的建议，我知道你可以在iphone上这么做。

编辑:审稿人建议我详细说明答案，所以我想用一种简单的方式来解释。 你的整个程序需要足够的时钟时间来打扰你。假设这是N秒。 你假设你可以加速它。唯一的方法就是让它在这段时间内不做它正在做的事情，占m秒。 你一开始并不知道这个东西是什么。您可以像所有程序员一样猜测，但它很容易是其他东西。不管是什么，下面是找到它的方法:

因为那个东西，不管它是什么，占了m/N的时间，这意味着如果你随机暂停它，你在它做那件事的时候抓住它的概率是m/N。当然，它可能在做其他事情，但暂停它，看看它在做什么。 现在再做一次。如果你看到它再次做同样的事情，你就更可疑了。

做10次，或者20次。现在，如果你看到它在多次暂停中做一些特定的事情(不管你怎么描述它)，你可以摆脱，你知道两件事。你大概知道需要花多少时间，但你很清楚要修复什么。 如果你还想知道能节省多少时间，那很简单。之前测量，修正，之后测量。如果你真的很失望，那就退出修复。

你知道这和测量有什么不同吗?这是发现，而不是测量。大多数分析都是基于尽可能精确地测量所花费的时间，就好像这很重要一样，并明确需要解决的问题。剖析并不能找到所有的问题，但是这种方法确实能找到所有的问题，而那些你没有找到的问题对你造成了伤害。

mach_absolute_time()有一个方便的包装器——它是来自CoreAnimation框架的CACurrentMediaTime()函数。

与NSDate或CFAbsoluteTimeGetCurrent()偏移量不同， mach_absolute_time()和CACurrentMediaTime()基于 主机内部时钟，精确，单原子测量，且不受影响 外部时间参考的更改，例如由时间引起的更改 区域、夏令时或闰秒。

ObjC

#import <QuartzCore/QuartzCore.h>

CFTimeInterval startTime = CACurrentMediaTime();
// Do your stuff here
CFTimeInterval endTime = CACurrentMediaTime();
NSLog(@"Total Runtime: %g s", endTime - startTime);

斯威夫特

import QuartzCore

let startTime = CACurrentMediaTime()
// Do your stuff here
let endTime = CACurrentMediaTime()
print("Total Runtime: \(endTime - startTime) s")

对于Swift 4，添加一个委托到你的类:

public protocol TimingDelegate: class {
    var _TICK: Date?{ get set }
}

extension TimingDelegate {
    var TICK: Date {
        _TICK = Date()
        return(_TICK)!
     }

    func TOCK(message: String)  {

        if (_TICK == nil){
            print("Call 'TICK' first!")
        }

        if (message == ""){
            print("\(Date().timeIntervalSince(_TICK!))")
        }
        else{
            print("\(message): \(Date().timeIntervalSince(_TICK!))")
        }
    }
}

加入我们班:

class MyViewcontroller: UIViewController, TimingDelegate

然后添加到你的类:

var _TICK: Date?

当你想为某事计时时，可以从以下开始:

TICK

最后:

TOCK("Timing the XXX routine")

你可以得到很好的时间(秒。部分秒)使用这个StopWatch类。它使用了iPhone的高精度计时器。使用NSDate只能获得秒级精度。这个版本是专门为自动发布和objective-c设计的。如果需要的话，我也有一个c++版本。你可以在这里找到c++版本。

StopWatch.h

#import <Foundation/Foundation.h>


@interface StopWatch : NSObject 
{
    uint64_t _start;
    uint64_t _stop;
    uint64_t _elapsed;
}

-(void) Start;
-(void) Stop;
-(void) StopWithContext:(NSString*) context;
-(double) seconds;
-(NSString*) description;
+(StopWatch*) stopWatch;
-(StopWatch*) init;
@end

StopWatch.m

#import "StopWatch.h"
#include <mach/mach_time.h>

@implementation StopWatch

-(void) Start
{
    _stop = 0;
    _elapsed = 0;
    _start = mach_absolute_time();
}
-(void) Stop
{
    _stop = mach_absolute_time();   
    if(_stop > _start)
    {
        _elapsed = _stop - _start;
    }
    else 
    {
        _elapsed = 0;
    }
    _start = mach_absolute_time();
}

-(void) StopWithContext:(NSString*) context
{
    _stop = mach_absolute_time();   
    if(_stop > _start)
    {
        _elapsed = _stop - _start;
    }
    else 
    {
        _elapsed = 0;
    }
    NSLog([NSString stringWithFormat:@"[%@] Stopped at %f",context,[self seconds]]);

    _start = mach_absolute_time();
}


-(double) seconds
{
    if(_elapsed > 0)
    {
        uint64_t elapsedTimeNano = 0;

        mach_timebase_info_data_t timeBaseInfo;
        mach_timebase_info(&timeBaseInfo);
        elapsedTimeNano = _elapsed * timeBaseInfo.numer / timeBaseInfo.denom;
        double elapsedSeconds = elapsedTimeNano * 1.0E-9;
        return elapsedSeconds;
    }
    return 0.0;
}
-(NSString*) description
{
    return [NSString stringWithFormat:@"%f secs.",[self seconds]];
}
+(StopWatch*) stopWatch
{
    StopWatch* obj = [[[StopWatch alloc] init] autorelease];
    return obj;
}
-(StopWatch*) init
{
    [super   init];
    return self;
}

@end

该类有一个返回自动释放对象的静态stopWatch方法。

调用start后，使用seconds方法获取运行时间。再次调用start来重新启动它。或者停下来停下来。在调用stop后，您仍然可以随时读取时间(调用秒数)。

函数中的示例(执行的定时调用)

-(void)SomeFunc
{
   StopWatch* stopWatch = [StopWatch stopWatch];
   [stopWatch Start];

   ... do stuff

   [stopWatch StopWithContext:[NSString stringWithFormat:@"Created %d Records",[records count]]];
}