在Swift中测量经过的时间

这是我尝试给出的最简单答案：

let startTime = Date().timeIntervalSince1970  // 1512538946.5705 seconds

// time passes (about 10 seconds)

let endTime = Date().timeIntervalSince1970    // 1512538956.57195 seconds
let elapsedTime = endTime - startTime         // 10.0014500617981 seconds

注意事项

• startTime 和 endTime 的类型是 TimeInterval，它只是 Double 的别名，因此很容易将其转换为 Int 或其他类型。时间以秒为单位，具有亚毫秒精度。
• 另请参阅 DateInterval，其中包括实际的开始和结束时间。
• 使用自1970年以来的时间类似于 Java 时间戳。

您可以像这样测量纳秒：

let startDate: NSDate = NSDate()

// your long procedure

let endDate: NSDate = NSDate()
let dateComponents: NSDateComponents = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian).components(NSCalendarUnit.CalendarUnitNanosecond, fromDate: startDate, toDate: endDate, options: NSCalendarOptions(0))
println("runtime is nanosecs : \(dateComponents.nanosecond)")

使用 XCTest 中提供的 measure 函数是检查经过时间/性能的推荐方法。
编写自己的测量块不可靠，因为代码块的性能（因此执行/经过的时间）受 CPU 缓存等因素的影响。
第二次调用函数比第一次调用可能更快，尽管可能会有几个百分点的差异。因此，通过执行自己的闭包（在这里随处可见）进行“基准测试”只执行一次，可能会得到与实际用户在生产中执行代码时不同的结果。 measure 函数多次调用您的代码块，模拟您的代码在生产中使用的性能/经过时间（至少提供更准确的结果）。

这是一个用于基本函数计时的静态 Swift3 类。它会按名称跟踪每个计时器。在您想要开始测量的地方使用以下方式调用它：

Stopwatch.start(name: "PhotoCapture")

调用此函数以捕获并打印经过的时间：

Call this to capture and print the time elapsed:

Stopwatch.timeElapsed(name: "PhotoCapture")

这是输出结果: *** PhotoCapture 耗时毫秒数: 1402.415125 如果需要使用纳秒，可以使用"useNanos"参数。 如有需要，请随意更改。

   class Stopwatch: NSObject {

  private static var watches = [String:TimeInterval]()

  private static func intervalFromMachTime(time: TimeInterval, useNanos: Bool) -> TimeInterval {
     var info = mach_timebase_info()
     guard mach_timebase_info(&info) == KERN_SUCCESS else { return -1 }
     let currentTime = mach_absolute_time()
     let nanos = currentTime * UInt64(info.numer) / UInt64(info.denom)
     if useNanos {
        return (TimeInterval(nanos) - time)
     }
     else {
        return (TimeInterval(nanos) - time) / TimeInterval(NSEC_PER_MSEC)
     }
  }

  static func start(name: String) {
     var info = mach_timebase_info()
     guard mach_timebase_info(&info) == KERN_SUCCESS else { return }
     let currentTime = mach_absolute_time()
     let nanos = currentTime * UInt64(info.numer) / UInt64(info.denom)
     watches[name] = TimeInterval(nanos)
  }

  static func timeElapsed(name: String) {
     return timeElapsed(name: name, useNanos: false)
  }

  static func timeElapsed(name: String, useNanos: Bool) {
     if let start = watches[name] {
        let unit = useNanos ? "nanos" : "ms"
        print("*** \(name) elapsed \(unit): \(intervalFromMachTime(time: start, useNanos: useNanos))")
     }
  }

}

将其放入完成块中以便于使用。

public class func secElapsed(completion: () -> Void) {
    let startDate: NSDate = NSDate()
    completion()
    let endDate: NSDate = NSDate()
    let timeInterval: Double = endDate.timeIntervalSinceDate(startDate)
    println("seconds: \(timeInterval)")
}

Swift 5+

我借鉴了Klaas的想法，创建了一个轻量级结构体来测量运行和间隔时间：

代码用法：

var timer = RunningTimer.init()
// Code to be timed
print("Running: \(timer) ") // Gives time interval
// Second code to be timed
print("Running: \(timer) ") // Gives final time

停止函数不需要被调用，因为打印函数将给出经过的时间。它可以重复调用以获取经过的时间。 但是，在代码的某个特定点停止计时器，请使用timer.stop()，它也可以用于返回时间（秒）：let seconds = timer.stop() 计时器停止后，间隔计时器不会停止，因此print("Running: \(timer) ")即使在几行代码之后也会给出正确的时间。

以下是RunningTimer的代码。它已经测试过Swift 2.1：

import CoreFoundation
// Usage:    var timer = RunningTimer.init()
// Start:    timer.start() to restart the timer
// Stop:     timer.stop() returns the time and stops the timer
// Duration: timer.duration returns the time
// May also be used with print(" \(timer) ")

struct RunningTimer: CustomStringConvertible {
    var begin:CFAbsoluteTime
    var end:CFAbsoluteTime
    
    init() {
        begin = CFAbsoluteTimeGetCurrent()
        end = 0
    }

    mutating func start() {
        begin = CFAbsoluteTimeGetCurrent()
        end = 0
    }

    mutating func stop() -> Double {
        if (end == 0) { end = CFAbsoluteTimeGetCurrent() }
        return Double(end - begin)
    }

    var duration:CFAbsoluteTime {
        get {
            if (end == 0) { return CFAbsoluteTimeGetCurrent() - begin } 
            else { return end - begin }
        }
    }

    var description:String {
         let time = duration
         if (time > 100) {return " \(time/60) min"}
         else if (time < 1e-6) {return " \(time*1e9) ns"}
         else if (time < 1e-3) {return " \(time*1e6) µs"}
         else if (time < 1) {return " \(time*1000) ms"}
         else {return " \(time) s"}
    }
}

从Swift 5.7（macOS 13.0，iOS 16.0，watchOS 9.0，tvOS 16.0）开始，您可以使用ContinuousClock和measure块，它返回一个Duration对象。它具有包含以秒或阿托秒为单位的测量时间的组件，即1×10⁻¹⁸秒。

let clock = ContinuousClock()

let duration = clock.measure {
    // put here what you want to measure
}

print("Duration: \(duration.components.seconds) seconds")
print("Duration: \(duration.components.attoseconds) attoseconds")

这是我写的方式。

 func measure<T>(task: () -> T) -> Double {
        let startTime = CFAbsoluteTimeGetCurrent()
        task()
        let endTime = CFAbsoluteTimeGetCurrent()
        let result = endTime - startTime
        return result
    }

要衡量一个算法，就像这样使用它。

let time = measure {
    var array = [2,4,5,2,5,7,3,123,213,12]
    array.sorted()
}

print("Block is running \(time) seconds.")

基于Franklin Yu的回答和Cœur的评论

细节

• Xcode 10.1 (10B61)
• Swift 4.2

解决方案1

measure(_:)

解决方案2

import Foundation

class Measurer<T: Numeric> {

    private let startClosure: ()->(T)
    private let endClosure: (_ beginningTime: T)->(T)

    init (startClosure: @escaping ()->(T), endClosure: @escaping (_ beginningTime: T)->(T)) {
        self.startClosure = startClosure
        self.endClosure = endClosure
    }

    init (getCurrentTimeClosure: @escaping ()->(T)) {
        startClosure = getCurrentTimeClosure
        endClosure = { beginningTime in
            return getCurrentTimeClosure() - beginningTime
        }
    }

    func measure(closure: ()->()) -> T {
        let value = startClosure()
        closure()
        return endClosure(value)
    }
}

解决方案 2 的使用方法

// Sample with ProcessInfo class

m = Measurer { ProcessInfo.processInfo.systemUptime }
time = m.measure {
    _ = (1...1000).map{_ in Int(arc4random()%100)}
}
print("ProcessInfo: \(time)")

// Sample with Posix clock API

m = Measurer(startClosure: {Double(clock())}) { (Double(clock()) - $0 ) / Double(CLOCKS_PER_SEC) }
time = m.measure {
    _ = (1...1000).map{_ in Int(arc4random()%100)}
}
print("POSIX: \(time)")

这是我想出来的代码片段，它在我的Macbook上使用Swift 4似乎可以工作。

从未在其他系统上测试过，但我认为值得分享。

typealias MonotonicTS = UInt64
let monotonic_now: () -> MonotonicTS = mach_absolute_time

let time_numer: UInt64
let time_denom: UInt64
do {
    var time_info = mach_timebase_info(numer: 0, denom: 0)
    mach_timebase_info(&time_info)
    time_numer = UInt64(time_info.numer)
    time_denom = UInt64(time_info.denom)
}

// returns time interval in seconds
func monotonic_diff(from: MonotonicTS, to: MonotonicTS) -> TimeInterval {
    let diff = (to - from)
    let nanos = Double(diff * time_numer / time_denom)
    return nanos / 1_000_000_000
}

func seconds_elapsed(since: MonotonicTS) -> TimeInterval {
    return monotonic_diff(from: since, to:monotonic_now())
}

这是如何使用它的示例：

let t1 = monotonic_now()
// .. some code to run ..
let elapsed = seconds_elapsed(since: t1)
print("Time elapsed: \(elapsed*1000)ms")

另一种方法是更明确地执行：

let t1 = monotonic_now()
// .. some code to run ..
let t2 = monotonic_now()
let elapsed = monotonic_diff(from: t1, to: t2)
print("Time elapsed: \(elapsed*1000)ms")