标签: grand-central-dispatch

我正在努力解决我的GCD代码中的死锁问题.然后我dispatch_debug在头文件中看到了这个函数<dispatch/object.h>.

/*!
 * @function dispatch_debug
 *
 * @abstract
 * Programmatically log debug information about a dispatch object.
 *
 * @param object
 * The object to introspect.
 *
 * @param message
 * The message to log above and beyond the introspection.
 */
__OSX_AVAILABLE_STARTING(__MAC_10_6,__IPHONE_4_0)
DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_NOTHROW __attribute__((__format__(printf,2,3)))
void
dispatch_debug(dispatch_object_t object, const char *message, ...);

但我无法做任何事情.我希望它会打印出状态并锁定或类似的东西.

这是我如何使用它:

grabber_queue = dispatch_queue_create("com.unpaq.tvguideplus.grabber", NULL);
dispatch_debug(grabber_queue, "grabber queue");

下面是一个示例函数,我尝试运行一个主要组,等待,然后在不同的线程上运行另外两个后台任务,等待,然后返回在下面显示的常规块中更改的值.下面显示的是我对如何做到这一点的猜测.如果我在一个块中运行这些块,它就可以工作.当我分开块时,它会失败.有没有人有他们如何完成类似的事情的例子？在此先感谢您的帮助.

-(NSString *)sampleFunction:(NSString*)inputString
{
 __block NSString *returnString;

 dispatch_group_t mainGroup = dispatch_group_create();
 dispatch_group_t otherGroup = dispatch_group_create();

 void (^firstBlock)(void) = ^(void)
 {
  ...
 };

 void (^secondBlock)(void) = ^(void)
 {
  ...
 };


 void (^thirdBlock)(void) = ^(void)
 {
  ...
 };

 dispatch_group_async(oneGroup, dispatch_get_global_queue(0, 0), firstBlock);

 dispatch_group_wait(oneGroup, sizeof(int));

 dispatch_group_async(otherGroup, dispatch_get_global_queue(0, 0), secondBlock);
 dispatch_group_async(otherGroup, dispatch_get_global_queue(0, 0), thirdBlock);

 dispatch_group_wait(otherGroup, sizeof(int));

 dispatch_release(userGroup); 
 dispatch_release(otherGroup);

 return returnString;
}

我想一次启动多个线程,所以我使用了以下代码.

我很困惑我是否应该创建一个队列并在其中放入许多操作,或者通过单个操作创建多个队列.

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
    for(int INDEX = 0; INDEX < 5; INDEX++) {
        dispatch_async(queue, ^{
            /*some code*/        
        }); 
    }

for(int INDEX = 0; INDEX < 5; INDEX++) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
            /*some code*/        
        }); 
    }

哪个是最佳的？另外,GCD中的线程数是否有限制？

我有一个loadImages方法

- (void)loadImages {
   dispatch_async(dispatch_get_global_queue(0, 0), ^{
       //this method loads images from a url, processes them
       //and then adds them to a property of its view controller 
       //@property (nonatomic, strong) NSMutableArray *storedImages;
   });
}

单击按钮时,视图将进入屏幕,并显示_storedImages中当前存在的所有图像

- (void)displayImages {
   for (NSString *link in _storedImages) {
      //displayImages
   }
}

此设置的问题是,如果用户在加载所有图像之前单击按钮,则并非所有图像都显示在屏幕上.

因此,如果单击该按钮,我想显示SVProgressHUD,并且loadImages dispatch_async方法仍在运行.

那么,如何跟踪dispatch_async何时完成？因为如果我知道这一点,那么我可以显示一个SVProgressHUD直到它完成.

另外,如果您知道如何动态加载/显示图像,那么信息也会有所帮助,即您单击按钮然后当您看到当前图像时,会下载并显示更多图像

首次感谢iOS开发人员!

好的,我找到了一个解决方案,但效率非常低,我相信有更好的方法可以做到这一点

1. Keep a boolean property doneLoadingImages which is set to NO …

Run Code Online (Sandbox Code Playgroud)

我正在构建一个iOS应用程序,它在后台线程上做了一些繁重的工作.

我使用创建我的线程

  dispatch_queue_t backgroundQueue;
  backgroundQueue =  dispatch_queue_create("MyQueue", NULL);

然后使用以下内容将其放入GCD:

   dispatch_async(backgroundQueue, ^
  {

   //some heavy operations here
   //each of them might run for >1 sec

  }

我只想要顺序执行队列,只要它不阻塞主线程.如果在20ms内从方法3,方法2和方法1调用该块....它们必须以3 - > 2 - > 1的顺序执行,因为每个方法的输出在下一个用完.

我是GCD的新手并且天真地想象一个调度队列将使用FIFO队列来执行顺序调用.但是,在目前的实施中,它远非顺序.

我尝试过使用NSLock,但他们也没有帮助.

我想知道在GCD中强制执行顺序执行的正确机制.

编辑1:

我正在声明一个全局队列:

 dispatch_queue_t backgroundQueue ;

并在viewDidLoad()中启动它:

 backgroundQueue = dispatch_queue_create("MyQueue", DISPATCH_QUEUE_SERIAL);
 //using DISPATCH_QUEUE_SERIAL was a new idea, I also tried using NULL

我正在使用GCD基本上调用另一个类中的方法:

 -(void)doAction()
  {

   dispatch_async(backgroundQueue, ^
        {
                   MyOtherClass *obj = [[MyOtherClass alloc] init];
                   [obj heavyMethod1:  param1 : param2];
                   [obj release];
               });

        }

 -(void)doAnotherAction()
  {

   dispatch_async(backgroundQueue, …

我使用常见的单例模式如下:

+ (SomeClass *)sharedInstance {
    static SomeClass *__sharedInstance;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        __sharedInstance = [[SomeClass alloc] init];
    });

    return __sharedInstance;
}

我知道SomeClass对象在我第一次调用[SomeClass sharedInstance]时被实例化,但是,SomeClass何时被dealloc'd？

这是在ARC下,那么编译器何时释放SomeClass静态对象？是否保证在我的应用程序的剩余生命周期？

GCD和街区非常好,方便.但是当我爱上它时,我发现发生了一件坏事.请看下面的代码:

[self functionA:^(BOOL success) {
  if (success) {
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(void) {
      [self functionB:^(NSError *error) {
        if (error != nil) {
          dispatch_async(dispatch_get_main_queue(), ^(void) {
            [self functionC:^(id result) {
              if (result) {
                [self functionD:^(BOOL success) {
                  if (success) {
                    [self DoSomething];
                  }
                }];
              }
            }];
          });
        }
      }];
    });
  }
}];

疯？是.我遇到了这个麻烦.

有没有人有避免像这样的嵌套块的经验？

编辑:

多谢你们.确切地说,我们有更优雅的方法来做到这一点.如:

• 事先声明块
• 使子块成为独立的功能

但我期望的是一般解决方案.也许是这样的:(下面的伪代码)

functionA.flat.success = [self functionB];
functionB.flat.isntnil = [self functionC];
functionB.flat.error = {};
functionC.flat.isntnil = [self functionD];
[flat call:functionA];

Xcode有一个GCD:Dispatch After Objective-C的代码片段:

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    <#code to be executed after a specified delay#>
});

Swift的等效代码片段是什么？

任何与UI相关的工作都需要在iOS主线程上运行.有时我们需要做一些异步工作,比如下载一个图像,我们可能会使用dispatch_async,当下载完成时,我们得到主线程并显示如下:

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
UIImage *overlayImage = [self faceOverlayImageFromImage:_image];
dispatch_async(dispatch_get_main_queue(), ^{
    [self fadeInNewImage:overlayImage];
});

});}

但是当我们在本地加载图像时,我们通常只是在不调度主线程的情况下执行此操作:

UIImageView *imageView = [[UIImageView alloc] initWithImage:@"myimage.png"];

我的问题是他们保证在主线程上运行吗？如果是,我们为什么要使用dispatch_get_main_queue()发送它？如果没有,为什么我们不需要在主线程上发送每个ui相关的工作？

我想将块A，B，C添加到全局并发队列中。之后，我想立即向同一队列添加障碍。

我希望A，B，C都以某种顺序调用，但是当所有块终止时，将调用该屏障。

如何保证在此序列的中间不会插入其他块？例如，如果在其他地方我将块X部署在同一队列中，则我不希望在屏障之前执行它。

MacOS和iOS上都可以使用相同的解决方案吗？