CODEWITHSUNDEEP
iosswift3xcode8grand-central-dispatchdispatch-after
user4790024
user4790024

Reputation:

How to create dispatch queue in Swift 3

In Swift 2, I was able to create queue with the following code:

let concurrentQueue = dispatch_queue_create("com.swift3.imageQueue", DISPATCH_QUEUE_CONCURRENT)

But this doesn't compile in Swift 3.

What is the preferred way to write this in Swift 3?

Upvotes: 420

Views: 381025

Answers (15)

Mithra Singam
Mithra Singam

Reputation: 2091

Update for swift 5

Serial Queue

let serialQueue = DispatchQueue.init(label: "serialQueue")
serialQueue.async {
    // code to execute
}

Concurrent Queue

let concurrentQueue = DispatchQueue.init(label: "concurrentQueue", qos: .background, attributes: .concurrent, autoreleaseFrequency: .inherit, target: nil)

concurrentQueue.async {
// code to execute
}

From Apple documentation:

Parameters

label

A string label to attach to the queue to uniquely identify it in debugging tools such as Instruments, sample, stackshots, and crash reports. Because applications, libraries, and frameworks can all create their own dispatch queues, a reverse-DNS naming style (com.example.myqueue) is recommended. This parameter is optional and can be NULL.

qos

The quality-of-service level to associate with the queue. This value determines the priority at which the system schedules tasks for execution. For a list of possible values, see DispatchQoS.QoSClass.

attributes

The attributes to associate with the queue. Include the concurrent attribute to create a dispatch queue that executes tasks concurrently. If you omit that attribute, the dispatch queue executes tasks serially.

autoreleaseFrequency

The frequency with which to autorelease objects created by the blocks that the queue schedules. For a list of possible values, see DispatchQueue.AutoreleaseFrequency.

target

The target queue on which to execute blocks. Specify DISPATCH_TARGET_QUEUE_DEFAULT if you want the system to provide a queue that is appropriate for the current object.

Upvotes: 9

t1ser
t1ser

Reputation: 1624

Compiles under >=Swift 3. This example contains most of the syntax that we need.

QoS - new quality of service syntax

weak self - to disrupt retain cycles

if self is not available, do nothing

async global utility queue - for network query, does not wait for the result, it is a concurrent queue, the block (usually) does not wait when started. Exception for a concurrent queue could be, when its task limit has been previously reached, then the queue temporarily turns into a serial queue and waits until some previous task in that queue completes.

async main queue - for touching the UI, the block does not wait for the result, but waits for its slot at the start. The main queue is a serial queue.

Of course, you need to add some error checking to this...

DispatchQueue.global(qos: .utility).async { [weak self] () -> Void in

    guard let strongSelf = self else { return }

    strongSelf.flickrPhoto.loadLargeImage { loadedFlickrPhoto, error in

        if error != nil {
            print("error:\(error)")
        } else {
            DispatchQueue.main.async { () -> Void in
                activityIndicator.removeFromSuperview()
                strongSelf.imageView.image = strongSelf.flickrPhoto.largeImage
            }
        }
    }
}

Upvotes: 57

Cosmin
Cosmin

Reputation: 7081

Since the OP question has already been answered above I just want to add some speed considerations:

It makes a lot of difference what priority class you assign to your async function in DispatchQueue.global.

I don't recommend running tasks with the .background thread priority especially on the iPhone X where the task seems to be allocated on the low power cores.

Here is some real data from a computationally intensive function that reads from an XML file (with buffering) and performs data interpolation:

Device name / .background / .utility / .default / .userInitiated / .userInteractive

  1. iPhone X: 18.7s / 6.3s / 1.8s / 1.8s / 1.8s
  2. iPhone 7: 4.6s / 3.1s / 3.0s / 2.8s / 2.6s
  3. iPhone 5s: 7.3s / 6.1s / 4.0s / 4.0s / 3.8s

Note that the data set is not the same for all devices. It's the biggest on the iPhone X and the smallest on the iPhone 5s.

Upvotes: 16

Deep
Deep

Reputation: 436

 let newQueue = DispatchQueue(label: "newname")
 newQueue.sync { 

 // your code

 }

Upvotes: 1

LC 웃
LC 웃

Reputation: 18998

Creating a concurrent queue

let concurrentQueue = DispatchQueue(label: "queuename", attributes: .concurrent)
concurrentQueue.sync {

}

Create a serial queue

let serialQueue = DispatchQueue(label: "queuename")
serialQueue.sync { 

}

Get main queue asynchronously

DispatchQueue.main.async {

}

Get main queue synchronously

DispatchQueue.main.sync {

}

To get one of the background thread

DispatchQueue.global(qos: .background).async {

}

Xcode 8.2 beta 2:

To get one of the background thread

DispatchQueue.global(qos: .default).async {

}

DispatchQueue.global().async {
    // qos' default value is ´DispatchQoS.QoSClass.default`
}

If you want to learn about using these queues .See this answer

Upvotes: 1174

Joseph Mikko Manoza
Joseph Mikko Manoza

Reputation: 296

For Swift 3 

   DispatchQueue.main.async {
        // Write your code here
    }

Upvotes: 1

Hitesh Chauhan
Hitesh Chauhan

Reputation: 1550

DispatchQueue.main.async(execute: {

// write code

})

Serial Queue :

let serial = DispatchQueue(label: "Queuename")

serial.sync { 

 //Code Here

}

Concurrent queue :

 let concurrent = DispatchQueue(label: "Queuename", attributes: .concurrent)

concurrent.sync {

 //Code Here
}

Upvotes: 2

Amul4608
Amul4608

Reputation: 1448

Swift 3

you want call some closure in swift code then you want to change in storyboard ya any type off change belong to view your application will crash

but you want to use dispatch method your application will not crash

async method

DispatchQueue.main.async 
{
 //Write code here                                   

}

sync method

DispatchQueue.main.sync 
{
     //Write code here                                  

}

Upvotes: 2

Hitesh Chauhan
Hitesh Chauhan

Reputation: 1550

DispatchQueue.main.async(execute: {
   // code
})

Upvotes: -3

Fritz Gerald Moran
Fritz Gerald Moran

Reputation: 45

 DispatchQueue.main.async {
          self.collectionView?.reloadData() // Depends if you were populating a collection view or table view
    }


OperationQueue.main.addOperation {
    self.lblGenre.text = self.movGenre
}

//use Operation Queue if you need to populate the objects(labels, imageview, textview) on your viewcontroller

Upvotes: 4

Nand Parikh
Nand Parikh

Reputation: 205

You can create dispatch queue using this code in swift 3.0

DispatchQueue.main.async
 {
   /*Write your code here*/
 }

   /* or */

let delayTime = DispatchTime.now() + Double(Int64(0.5 * Double(NSEC_PER_SEC))) / Double(NSEC_PER_SEC)                   
DispatchQueue.main.asyncAfter(deadline: delayTime)
{
  /*Write your code here*/
}

Upvotes: -4

gosborne3
gosborne3

Reputation: 47

   let concurrentQueue = dispatch_queue_create("com.swift3.imageQueue", DISPATCH_QUEUE_CONCURRENT) //Swift 2 version

   let concurrentQueue = DispatchQueue(label:"com.swift3.imageQueue", attributes: .concurrent) //Swift 3 version

I re-worked your code in Xcode 8, Swift 3 and the changes are marked in contrast to your Swift 2 version.

Upvotes: 2

Asfand Shabbir
Asfand Shabbir

Reputation: 1294

I did this and this is especially important if you want to refresh your UI to show new data without user noticing like in UITableView or UIPickerView.

    DispatchQueue.main.async
 {
   /*Write your thread code here*/
 }

Upvotes: 6

R Thomas
R Thomas

Reputation: 445

Compiled in XCode 8, Swift 3 https://github.com/rpthomas/Jedisware

 @IBAction func tap(_ sender: AnyObject) {

    let thisEmail = "emailaddress.com"
    let thisPassword = "myPassword" 

    DispatchQueue.global(qos: .background).async {

        // Validate user input

        let result = self.validate(thisEmail, password: thisPassword)

        // Go back to the main thread to update the UI
        DispatchQueue.main.async {
            if !result
            {
                self.displayFailureAlert()
            }

        }
    }

}

Upvotes: 29

tylernol
tylernol

Reputation: 171

it is now simply: 

let serialQueue = DispatchQueue(label: "my serial queue")

the default is serial, to get concurrent, you use the optional attributes argument .concurrent

Upvotes: -3

Related Questions