스레딩을 신속하게 사용하는 방법은 무엇입니까?

dispatchOnMainThread:^{

    NSLog(@"Block Executed On %s", dispatch_queue_get_label(dispatch_get_current_queue()));

}];

답변

스위프트 3.0+

Swift 3.0에서는 많은 것들이 현대화 되었습니다. 백그라운드 스레드에서 무언가를 실행하면 다음과 같습니다.

DispatchQueue.global(qos: .background).async {
    print("This is run on the background queue")

    DispatchQueue.main.async {
        print("This is run on the main queue, after the previous code in outer block")
    }
}

스위프트 1.2 ~ 2.3

let qualityOfServiceClass = QOS_CLASS_BACKGROUND
let backgroundQueue = dispatch_get_global_queue(qualityOfServiceClass, 0)
dispatch_async(backgroundQueue, {
    print("This is run on the background queue")

    dispatch_async(dispatch_get_main_queue(), { () -> Void in
        print("This is run on the main queue, after the previous code in outer block")
    })
})

Pre Swift 1.2 – 알려진 문제

Swift 1.1 현재 Apple은 약간의 수정없이 위의 구문을 지원하지 않았습니다. 전달 QOS_CLASS_BACKGROUND이 실제로 작동하지 않고 대신을 사용하십시오 Int(QOS_CLASS_BACKGROUND.value).

자세한 내용은 Apple 설명서를 참조하십시오.

답변

가장 좋은 방법은 여러 번 액세스 할 수있는 재사용 가능한 기능을 정의하는 것입니다.

재사용 가능한 기능 :

예를 들어 전역 함수로서 AppDelegate.swift와 같은 곳.

func backgroundThread(_ delay: Double = 0.0, background: (() -> Void)? = nil, completion: (() -> Void)? = nil) {
    dispatch_async(dispatch_get_global_queue(Int(QOS_CLASS_USER_INITIATED.value), 0)) {
        background?()

        let popTime = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
        dispatch_after(popTime, dispatch_get_main_queue()) {
            completion?()
        }
    }
}

참고 : 스위프트 2.0, 대체 QOS_CLASS_USER_INITIATED.value을 하여 전술 QOS_CLASS_USER_INITIATED.rawValue 대신

용법:

A. 백그라운드에서 3 초 지연된 프로세스를 실행하려면

    backgroundThread(3.0, background: {
            // Your background function here
    })

B. 백그라운드에서 프로세스를 실행하려면 포 그라운드에서 완료를 실행하십시오.

    backgroundThread(background: {
            // Your function here to run in the background
    },
    completion: {
            // A function to run in the foreground when the background thread is complete
    })

C. 3 초 지연-백그라운드 매개 변수없이 완료 매개 변수 사용에 유의하십시오.

    backgroundThread(3.0, completion: {
            // Your delayed function here to be run in the foreground
    })

답변

swift5의 Dan Beaulieu의 답변 (swift 3.0.1부터 작동).

스위프트 5.0.1

extension DispatchQueue {

    static func background(delay: Double = 0.0, background: (()->Void)? = nil, completion: (() -> Void)? = nil) {
        DispatchQueue.global(qos: .background).async {
            background?()
            if let completion = completion {
                DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: {
                    completion()
                })
            }
        }
    }

}

용법

DispatchQueue.background(delay: 3.0, background: {
    // do something in background
}, completion: {
    // when background job finishes, wait 3 seconds and do something in main thread
})

DispatchQueue.background(background: {
    // do something in background
}, completion:{
    // when background job finished, do something in main thread
})

DispatchQueue.background(delay: 3.0, completion:{
    // do something in main thread after 3 seconds
})

답변

스위프트 3 버전

Swift 3는 새로운 DispatchQueue클래스를 사용하여 대기열과 스레드를 관리합니다. 백그라운드 스레드에서 무언가를 실행하려면 다음을 사용하십시오.

let backgroundQueue = DispatchQueue(label: "com.app.queue", qos: .background)
backgroundQueue.async {
    print("Run on background thread")
}

또는 두 줄의 코드로 무언가를 원한다면 :

DispatchQueue.global(qos: .background).async {
    print("Run on background thread")

    DispatchQueue.main.async {
        print("We finished that.")
        // only back on the main thread, may you access UI:
        label.text = "Done."
    }
}

이 튜토리얼 에서 Swift 3의 GDC에 대한 자세한 정보를 얻을 수 있습니다 .

답변

에서 제임슨 Quave의 튜토리얼

스위프트 2

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), {
    //All stuff here
})

답변

Swift 4.2 및 Xcode 10.1에서

대기열에는 세 가지 유형이 있습니다.

1. 메인 큐 :
메인 큐는 시스템에 의해 생성되고 응용 프로그램 메인 스레드와 연결된 직렬 큐입니다.

2. Global Queue :
Global Queue는 작업 우선 순위와 관련하여 요청할 수있는 동시 대기열입니다.

3. 사용자 지정 대기열 : 사용자 가 만들 수 있습니다. 사용자 정의 동시 큐는 항상 QoS (Quality of Service) 특성을 지정하여 글로벌 큐 중 하나에 맵핑됩니다.

DispatchQueue.main//Main thread
DispatchQueue.global(qos: .userInitiated)// High Priority
DispatchQueue.global(qos: .userInteractive)//High Priority (Little Higher than userInitiated)
DispatchQueue.global(qos: .background)//Lowest Priority
DispatchQueue.global(qos: .default)//Normal Priority (after High but before Low)
DispatchQueue.global(qos: .utility)//Low Priority
DispatchQueue.global(qos: .unspecified)//Absence of Quality

이 모든 대기열은 두 가지 방법으로 실행될 수 있습니다

1. 동기 실행

2. 비동기 실행

DispatchQueue.global(qos: .background).async {
    // do your job here
    DispatchQueue.main.async {
        // update ui here
    }
}

//Perform some task and update UI immediately.
DispatchQueue.global(qos: .userInitiated).async {
    // Perform task
    DispatchQueue.main.async {
        // Update UI
        self.tableView.reloadData()
    }
}

//To call or execute function after some time
DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) {
    //Here call your function
}

//If you want to do changes in UI use this
DispatchQueue.main.async(execute: {
    //Update UI
    self.tableView.reloadData()
})

AppCoda에서 : https://www.appcoda.com/grand-central-dispatch/

//This will print synchronously means, it will print 1-9 & 100-109
func simpleQueues() {
    let queue = DispatchQueue(label: "com.appcoda.myqueue")

    queue.sync {
        for i in 0..<10 {
            print("?", i)
        }
    }

    for i in 100..<110 {
        print("Ⓜ️", i)
    }
}

//This will print asynchronously
func simpleQueues() {
    let queue = DispatchQueue(label: "com.appcoda.myqueue")

    queue.async {
        for i in 0..<10 {
            print("?", i)
        }
    }

    for i in 100..<110 {
        print("Ⓜ️", i)
    }
}

답변

스위프트 4.x

이것을 일부 파일에 넣으십시오.

func background(work: @escaping () -> ()) {
    DispatchQueue.global(qos: .userInitiated).async {
        work()
    }
}

func main(work: @escaping () -> ()) {
    DispatchQueue.main.async {
        work()
    }
}

그런 다음 필요한 곳으로 전화하십시오.

background {
     //background job
     main {
       //update UI (or what you need to do in main thread)
     }
}