1. Write a BLOCK method that takes 2 parameters as string and returns a string with appending received 2 strings from parameter.

Objective C

NSString* (^myBlock)(NSString*, NSString*) = ^(NSString* a, NSString* b){
    return [a stringByAppendingString:b];
};
NSLog(@"%@",myBlock(@"yyy",@"xxxx"));

Swift 3

import UIKit
import Foundation

var myblock1: (String, String) -> String = {
    return $0 + $1
}

var myblock2: (String, String) -> String = {
    str1, str2 in
    return str1 + str2
}

var str1 = "xxxx"
var str2 = "yyyy"

print(myblock1(str1, str2))
print(myblock2("aaa", "bbb"))

2. an array of block, asynchronous execute blcok. when all blocks finish, print sth.：

// main queue
//OBJECTIVE-C
dispatch_queue_t queue = ispatch_get_main_queue();


//OBJECTIVE-C
// 串行队列
dispatch_queue_t queue= dispatch_queue_create("tk.bourne.testQueue", NULL);
dispatch_queue_t queue= dispatch_queue_create("tk.bourne.testQueue", DISPATCH_QUEUE_SERIAL);
// 并行队列
dispatch_queue_t queue= dispatch_queue_create("tk.bourne.testQueue", DISPATCH_QUEUE_CONCURRENT);

// 全局并行队列
//OBJECTIVE-C
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

Objective C

// Version 1, concurrent OperationQueue with OperationDependence
NSMutableArray *blockArray = [NSMutableArray array];
[blockArray addObject:^{NSLog(@"===111,%@", [NSThread currentThread]);}];

[blockArray addObject:^{NSLog(@"===222,%@", [NSThread currentThread]);}];
[blockArray addObject:^{NSLog(@"===333,%@", [NSThread currentThread]);}];
[blockArray addObject:^{NSLog(@"===444,%@", [NSThread currentThread]);}];


NSBlockOperation* op = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"all done");
}];

NSOperationQueue *queue = [[NSOperationQueue alloc]init];

for (id block in blockArray) {
    NSBlockOperation *myOp = [NSBlockOperation blockOperationWithBl
ock:block];
    [op addDependency:myOp];
    [queue addOperation:myOp];
}
[queue addOperation:op];

// Version 2, OperationQueue, 
NSOperationQueue *queue = [[NSOperationQueue alloc]init];
for (id block in blockArray) {
    //void(^test)() = block;
    [queue addOperationWithBlock:block];
}

[queue waitUntilAllOperationsAreFinished];
NSLog(@"All Done");

// Version 3, GCD version
dispatch_queue_t queue = dispatch_get_global_queue(0, 0); // concurrent queue
dispatch_group_t group = dispatch_group_create();
for (id block in blockArray) {
    dispatch_group_async(group, queue, block);

}

dispatch_notify(group, queue, ^{NSLog(@"********");});

Swift 3

/// async execute blocks

typealias BlockType = () -> Void

var block1: BlockType = {
    print("block 1 in \(Thread.current)")
}
var block2: BlockType = {
    print("block 2 in \(Thread.current)")
}
var block3: BlockType = {
    print("block 3 in \(Thread.current)")
}

var blocks = Array<BlockType>()

blocks.append(block1)
blocks.append(block2)
blocks.append(block3)
let serialQueue = DispatchQueue(label: "SerialQueue", DISPATCH_QUEUE_SERIAL)
// or let serialQueue = DispatchQueue(label: "SerialQueue", NULL)
// Concurrent queue
let queue = DispatchQueue(label: "Concurrent queue", DISPATCH_QUEUE_CONCURRENT)


// Version 1, OperationQueue
/// using concurrent queue, add operation dependence for the finish block
print("Block async, version 1")
print("before" + "\(Thread.current)")
var op1 = OperationQueue()
op1.name = "concurrent op1 queue"
let finishBlockOp = BlockOperation {
    print("finish op1 \(Thread.current)")
}
for block in blocks {
    let operation = BlockOperation(block: block)
    finishBlockOp.addDependency(operation)
    op1.addOperation(operation)
}
op1.addOperation(finishBlockOp)
print("after" + "\(Thread.current)")




/// Version 2, OperationQueue
/// using serial queue, add completion in the last
print("Block async, version 2")
print("before" + "\(Thread.current)")
var op2 = OperationQueue()
op2.underlyingQueue = serialQueue
//op2.maxConcurrentOperationCount = 1
op2.name = "serial op2 queue"

var completionBlock: BlockType = {
    print("finish op2 \(Thread.current)")
}

for block in blocks {
    op2.addOperation(block)
}
op2.addOperation(completionBlock)
print("after" + "\(Thread.current)")



/// Version 3, GCD
/// use DispatchGroup and notify block to know the group completion
print("Block async, version 3 GCD")
print("before" + "\(Thread.current)")

let queue = DispatchQueue(label: "Concurrent queue", DISPATCH_QUEUE_CONCURRENT)
let group = DispatchGroup()
let lastBlockGCD: BlockType = {
    print("finish GCD \(Thread.current)")
}

var testBlock1: BlockType = {
    print("block 1 in \(Thread.current)")
}
var testBlock2: BlockType = {
    print("block 2 in \(Thread.current)")
}
var testBlock3: BlockType = {
    print("block 3 in \(Thread.current)")
}

var testBlocks = Array<BlockType>()
testBlocks.append(contentsOf: [testBlock1, testBlock2, testBlock3])


for block in testBlocks {
    //let workItem = DispatchWorkItem(block: block)
    //queue.async(group: group, execute: workItem)
    queue.async(group: group, execute: block)
}

group.notify(queue: queue, execute: lastBlockGCD)

print("after" + "\(Thread.current)")