Ios 如何在后台线程中调用API？

我正在我的应用程序中使用Alamofire进行API调用

现在我想在后台线程中调用一些API，以便在调用该API时，其他功能正常工作。那我怎么能在阿拉莫菲尔做到这一点呢

这就是我调用APi的方式

func GetDesignationList(pharmacyId : String,completion:(ManageDesignation : ManageDesignationListModel)-> Void)  {
let url = "\(VendorURL)all_employee_designation_list"
let param : [String : AnyObject] = [

    "pharmacyId" : pharmacyId
]

Alamofire.request(.GET, url, parameters: param, encoding: .URL).responseObject { (response:Response<ManageDesignationListModel, NSError>) in
    switch response.result
    {
    case.Success(let value) :
        var ManageDesignationObject : ManageDesignationListModel?
        ManageDesignationObject = value
        completion(ManageDesignation: ManageDesignationObject!)
    case.Failure(let error) : break

    }
}

}

func-GetDesignationList（pharmacyId:String，完成：（ManageSignation:ManageSignationListModel）->Void）{
let url=“\（供应商url）所有员工指定列表”
let param:[字符串：AnyObject]=[
“pharmacyId”：pharmacyId
]
请求（.GET，url，参数：param，编码：.url）。响应对象{（响应：响应）在
开关响应。结果
{
成功案例（let value）：
var ManageSignationObject:ManageSignationListModel？
ManageDesignationObject=值
完成（ManageDesignation:ManageDesignationObject！）
案例失败（let错误）：中断
}
}
}

您已经做对了。Alamofire在后台线程中调用web服务。如果要测试它是否异步工作，可以在调用后添加一个

print（“1”）

，并在

响应中添加一个
print（“2”）
。
同时调用Web服务和UI

dispatch_queue_t downloadQueue = dispatch_queue_create("webservice", NULL);
dispatch_async(downloadQueue, ^{


        // do our long running process here
        [NSThread sleepForTimeInterval:10];


        // do any UI stuff on the main UI thread
        dispatch_async(dispatch_get_main_queue(), ^{

        });


    });

正如所指出的，阿拉莫菲尔已经为你做了这项工作

但要回答“如何在后台线程中调用API”的问题

可以分派到不同线程的类：

class Dispatcher
{
    enum DispatchLevel
    {
        case Main, UserInteractive, UserInitiated, Utility, Background
        var dispatchQueue: OS_dispatch_queue {
            switch self {
            case .Main:             return dispatch_get_main_queue()
            case .UserInteractive:  return dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0)
            case .UserInitiated:    return dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)
            case .Utility:          return dispatch_get_global_queue(QOS_CLASS_UTILITY, 0)
            case .Background:       return dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0) }
        }
    }

    func delay(bySeconds seconds: Double, dispatchLevel: DispatchLevel = .Main, closure: () -> Void)
    {
        let time = dispatch_time(DISPATCH_TIME_NOW, Int64(seconds * Double(NSEC_PER_SEC)))
        dispatch_after(time, dispatchLevel.dispatchQueue, closure)
    }   
}

let myDispatch = Dispatcher()

myDispatch.delay(bySeconds: 10, dispatchLevel: .Background)
{
    print("Do something here on background thread")
}

像这样使用它：

class Dispatcher
{
    enum DispatchLevel
    {
        case Main, UserInteractive, UserInitiated, Utility, Background
        var dispatchQueue: OS_dispatch_queue {
            switch self {
            case .Main:             return dispatch_get_main_queue()
            case .UserInteractive:  return dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0)
            case .UserInitiated:    return dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)
            case .Utility:          return dispatch_get_global_queue(QOS_CLASS_UTILITY, 0)
            case .Background:       return dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0) }
        }
    }

    func delay(bySeconds seconds: Double, dispatchLevel: DispatchLevel = .Main, closure: () -> Void)
    {
        let time = dispatch_time(DISPATCH_TIME_NOW, Int64(seconds * Double(NSEC_PER_SEC)))
        dispatch_after(time, dispatchLevel.dispatchQueue, closure)
    }   
}

let myDispatch = Dispatcher()

myDispatch.delay(bySeconds: 10, dispatchLevel: .Background)
{
    print("Do something here on background thread")
}

您可以使用dispatch_queues.Alamofire本身将在后台线程中完成它的工作，这样您就不必在那里投入精力。在执行alamofire块时，您希望执行的任何其他函数，您都可以正常执行。如果您想尽快获得alamofire结果，您会遇到一个问题，因为这是一个
异步
过程，不会真正等待任何其他作业先完成。ok@Dershowitz 123 alamofire在后台线程中完成其所有工作？？是的！这是一个
异步
过程，它在后台线程上完成其工作，确保您的UI不会冻结或降低应用程序的整体速度。