PerformSelector 可能会导致泄漏，因为它的选择器未知

Question

我收到 ARC 编译器发出的以下警告：

"performSelector may cause a leak because its selector is unknown".

这就是我正在做的事情：

[_controller performSelector:NSSelectorFromString(@"someMethod")];

为什么我会收到此警告？我知道编译器无法检查选择器是否存在，但是为什么这会导致泄漏呢？我怎样才能改变我的代码，这样我就不会再收到这个警告了？

Answer 1

解决方案

编译器对此发出警告是有原因的。简单地忽略此警告的情况很少见，而且很容易解决。方法如下：

if (!_controller) { return; }
SEL selector = NSSelectorFromString(@"someMethod");
IMP imp = [_controller methodForSelector:selector];
void (*func)(id, SEL) = (void *)imp;
func(_controller, selector);

或者更简洁（虽然很难阅读并且没有防护）：

SEL selector = NSSelectorFromString(@"someMethod");
((void (*)(id, SEL))[_controller methodForSelector:selector])(_controller, selector);

解释

这里发生的事情是您向控制器询问与控制器对应的方法的 C 函数指针。所有 NSObject 都会响应 methodForSelector:，但您也可以在 Objective-C 运行时中使用 class_getMethodImplementation（如果您只有协议引用，则很有用） ，如 id）。这些函数指针称为 IMP，并且是简单的 typedefed 函数指针 (id (*IMP)(id, SEL, ...))¹。这可能接近该方法的实际方法签名，但并不总是完全匹配。

获得 IMP 后，您需要将其转换为函数指针，其中包含 ARC 所需的所有详细信息（包括两个隐式隐藏参数 self 和 每个 Objective-C 方法调用的 _cmd）。这是在第三行中处理的（右侧的 (void *) 只是告诉编译器您知道自己在做什么，并且不会生成警告，因为指针类型不会匹配）。

最后，调用函数指针²。

复杂示例

当选择器接受参数或返回值时，您必须稍作更改：

SEL selector = NSSelectorFromString(@"processRegion:ofView:");
IMP imp = [_controller methodForSelector:selector];
CGRect (*func)(id, SEL, CGRect, UIView *) = (void *)imp;
CGRect result = _controller ?
  func(_controller, selector, someRect, someView) : CGRectZero;

警告的原因 出现

此警告的原因是，使用 ARC，运行时需要知道如何处理您所选择的方法的结果。正在打电话。结果可以是任何内容：void、int、char、NSString *、id > 等。ARC 通常从您正在使用的对象类型的标头获取此信息。³

对于返回值，ARC 实际上只考虑 4 件事：^{4< /sup>}

1. 忽略非对象类型（void、int 等）
2. 保留对象值，然后在不再使用时释放它（标准假设）
3. 不再使用时释放新的对象值（< code>init/ copy 系列或归因于 ns_returns_retained)
4. 不执行任何操作 &假设返回的对象值在本地范围内有效（直到最内部的释放池被耗尽，归因于ns_returns_autoreleased）

对methodForSelector：的调用假设该方法的返回值它调用的是一个对象，但不保留/释放它。因此，如果您的对象应该像上面#3 中那样被释放（即您调用的方法返回一个新对象），那么您最终可能会造成泄漏。

对于您尝试调用返回 void 或其他非对象的选择器，您可以启用编译器功能来忽略警告，但这可能很危险。我见过 Clang 如何处理未分配给局部变量的返回值的一些迭代。启用 ARC 后，即使您不想使用它，它也没有理由不能保留和释放从 methodForSelector: 返回的对象值。从编译器的角度来看，它毕竟是一个对象。这意味着，如果您调用的方法 someMethod 返回非对象（包括 void），则最终可能会保留/释放垃圾指针值和崩溃。

其他参数

一个考虑因素是，这与 performSelector:withObject: 会发生相同的警告，并且如果不声明该方法如何使用参数，您可能会遇到类似的问题。 ARC 允许声明使用的参数，并且如果该方法使用该参数，您最终可能会向僵尸发送消息并崩溃。有多种方法可以通过桥接转换来解决这个问题，但实际上最好简单地使用上面的 IMP 和函数指针方法。由于消耗的参数很少成为问题，因此这种情况不太可能出现。

静态选择器

有趣的是，编译器不会抱怨静态声明的选择器：

[_controller performSelector:@selector(someMethod)];

原因是编译器实际上能够在编译期间记录有关选择器和对象的所有信息。它不需要对任何事情做出任何假设。 （我一年前通过查看源代码检查了这一点，但现在没有参考资料。）

抑制

在尝试考虑抑制此警告是必要的并且良好的代码设计的情况时，我出现空白。如果有人有过需要消除此警告的经验（并且上述方法不能正确处理问题），请分享。

更多

也可以构建一个 NSMethodInitation 来处理这个问题，但是这样做需要更多的输入并且速度也更慢，所以没有理由这样做。

历史

当performSelector: 系列方法首次添加到 Objective-C 时，ARC 还不存在。在创建 ARC 时，Apple 决定应该为这些方法生成警告，以指导开发人员使用其他方法来显式定义在通过命名选择器发送任意消息时应如何处理内存。在 Objective-C 中，开发人员可以通过对原始函数指针使用 C 风格转换来实现此目的。

随着 Swift 的推出，Apple 已记录 performSelector: 系列方法被视为“本质上不安全”，并且它们不适用于 Swift。

随着时间的推移，我们看到了这样的进展：

1. Objective-C 的早期版本允许 performSelector: （手动内存管理）
2. Objective-C with ARC 警告使用 performSelector:
3. Swift 确实如此无法访问 performSelector: 并将这些方法记录为“本质上不安全”

但是，基于命名选择器发送消息的想法并不是“本质上不安全”的功能。这个想法已经在 Objective-C 以及许多其他编程语言中成功使用了很长时间。

---

¹ 所有 Objective-C 方法都有两个隐藏参数，self 和 _cmd，它们在调用方法时隐式添加。

² 在 C 中调用 NULL 函数是不安全的。用于检查控制器是否存在的防护确保我们拥有一个对象。因此，我们知道我们将从 methodForSelector: 获得一个 IMP（尽管它可能是 _objc_msgForward，进入消息转发系统）。基本上，有了警卫就位，我们知道我们有一个函数可以调用。

³ 实际上，如果将对象声明为 id 并且没有导入所有标头，它可能会获取错误的信息。您最终可能会在编译器认为正常的代码中发生崩溃。这种情况非常罕见，但也有可能发生。通常您只会收到一条警告，表明它不知道要选择两个方法签名中的哪一个。

⁴ 请参阅有关保留返回值<的 ARC 参考/a> 和 未保留返回值以获取更多详细信息。

Answer 2

在 Xcode 4.2 中的 LLVM 3.0 编译器中，您可以按如下方式抑制警告：

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
    [self.ticketTarget performSelector: self.ticketAction withObject: self];
#pragma clang diagnostic pop

如果您在多个位置收到错误，并且想要使用 C 宏系统来隐藏编译指示，您可以定义一个宏以使其更容易抑制警告：

#define SuppressPerformSelectorLeakWarning(Stuff) \
    do { \
        _Pragma("clang diagnostic push") \
        _Pragma("clang diagnostic ignored \"-Warc-performSelector-leaks\"") \
        Stuff; \
        _Pragma("clang diagnostic pop") \
    } while (0)

您可以像这样使用宏：

SuppressPerformSelectorLeakWarning(
    [_target performSelector:_action withObject:self]
);

如果您需要执行消息的结果，您可以这样做：

id result;
SuppressPerformSelectorLeakWarning(
    result = [_target performSelector:_action withObject:self]
);

Answer 3

我对此的猜测是：由于编译器不知道选择器，ARC 无法强制执行正确的内存管理。

事实上，有时内存管理通过特定约定与方法名称联系在一起。具体来说，我正在考虑便捷构造函数与make方法；前者按照惯例返回一个自动释放的对象；后者是保留的对象。该约定基于选择器的名称，因此如果编译器不知道选择器，则它无法强制执行正确的内存管理规则。

如果这是正确的，我认为您可以安全地使用您的代码，只要您确保内存管理方面一切正常（例如，您的方法不返回它们分配的对象）。

Answer 4

在您的项目构建设置中的其他警告标志 (WARNING_CFLAGS) 下，添加
-Wno-arc-performSelector-leaks

现在只需确保您调用的选择器不会导致您的对象被保留或复制。

Answer 5

作为编译器允许覆盖警告之前的解决方法，您可以使用运行时。

您需要标题：

#import <objc/message.h>

然后尝试以下：

// For strict compilers.
((id(*)(id,SEL))objc_msgSend)(_controller, sel_getUid("someMethod"));

或而

// Old answer's code:
objc_msgSend(_controller, NSSelectorFromString(@"someMethod"));

不是：

[_controller performSelector:NSSelectorFromString(@"someMethod")];

Answer 6

要仅忽略带有执行选择器的文件中的错误，请添加 #pragma，如下所示：

#pragma clang diagnostic ignored "-Warc-performSelector-leaks"

这将忽略此行上的警告，但仍允许在项目的其余部分中使用它。

Answer 7

奇怪但正确：如果可以接受（即结果为空并且您不介意让运行循环循环一次），请添加延迟，即使这是零：

[_controller performSelector:NSSelectorFromString(@"someMethod")
    withObject:nil
    afterDelay:0];

这会删除警告，大概是因为它向编译器保证没有对象可以返回并不知何故管理不善。

Answer 8

这是基于上面给出的答案的更新宏。这应该允许您甚至使用 return 语句来包装您的代码。

#define SUPPRESS_PERFORM_SELECTOR_LEAK_WARNING(code)                        \
    _Pragma("clang diagnostic push")                                        \
    _Pragma("clang diagnostic ignored \"-Warc-performSelector-leaks\"")     \
    code;                                                                   \
    _Pragma("clang diagnostic pop")                                         \


SUPPRESS_PERFORM_SELECTOR_LEAK_WARNING(
    return [_target performSelector:_action withObject:self]
);

Answer 9

此代码不涉及编译器标志或直接运行时调用：

SEL selector = @selector(zeroArgumentMethod);
NSMethodSignature *methodSig = [[self class] instanceMethodSignatureForSelector:selector];
NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:methodSig];
[invocation setSelector:selector];
[invocation setTarget:self];
[invocation invoke];

NSInitation 允许设置多个参数，因此与 performSelector 不同，它适用于任何方法。

Answer 10

好吧，这里有很多答案，但由于这有点不同，因此结合了一些我认为应该放入的答案。我使用 NSObject 类别来检查以确保选择器返回 void，并且还抑制编译器警告。

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import "Debug.h" // not given; just an assert

@interface NSObject (Extras)

// Enforce the rule that the selector used must return void.
- (void) performVoidReturnSelector:(SEL)aSelector withObject:(id)object;
- (void) performVoidReturnSelector:(SEL)aSelector;

@end

@implementation NSObject (Extras)

// Apparently the reason the regular performSelect gives a compile time warning is that the system doesn't know the return type. I'm going to (a) make sure that the return type is void, and (b) disable this warning
// See http://stackoverflow.com/questions/7017281/performselector-may-cause-a-leak-because-its-selector-is-unknown

- (void) checkSelector:(SEL)aSelector {
    // See http://stackoverflow.com/questions/14602854/objective-c-is-there-a-way-to-check-a-selector-return-value
    Method m = class_getInstanceMethod([self class], aSelector);
    char type[128];
    method_getReturnType(m, type, sizeof(type));

    NSString *message = [[NSString alloc] initWithFormat:@"NSObject+Extras.performVoidReturnSelector: %@.%@ selector (type: %s)", [self class], NSStringFromSelector(aSelector), type];
    NSLog(@"%@", message);

    if (type[0] != 'v') {
        message = [[NSString alloc] initWithFormat:@"%@ was not void", message];
        [Debug assertTrue:FALSE withMessage:message];
    }
}

- (void) performVoidReturnSelector:(SEL)aSelector withObject:(id)object {
    [self checkSelector:aSelector];

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
    // Since the selector (aSelector) is returning void, it doesn't make sense to try to obtain the return result of performSelector. In fact, if we do, it crashes the app.
    [self performSelector: aSelector withObject: object];
#pragma clang diagnostic pop    
}

- (void) performVoidReturnSelector:(SEL)aSelector {
    [self checkSelector:aSelector];

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
    [self performSelector: aSelector];
#pragma clang diagnostic pop
}

@end

Answer 11

为了子孙后代，我决定投身其中 :)

最近，我看到越来越多的重组远离 target/selector 范式，有利于协议、块等。但是，有一个我已经使用过几次的 performSelector 的直接替代品：

[NSApp sendAction: NSSelectorFromString(@"someMethod") to: _controller from: nil];

它们似乎是一种干净的、ARC 安全的、和几乎相同的替代品performSelector 无需过多使用 objc_msgSend()。

不过，我不知道 iOS 上是否有类似的功能。

Answer 12

Matt Galloway 在此帖子上的回答解释了原因：

考虑以下因素：

id anotherObject1 = [someObject PerformSelector:@selector(copy)];
id anotherObject2 = [someObject PerformSelector:@selector(giveMeAnotherNonRetainedObject)];

现在，ARC 如何知道第一个返回的对象的保留计数为 1，而第二个则返回一个对象
返回一个自动释放的对象？

如果您忽略返回值，那么抑制警告通常是安全的。如果您确实需要从 PerformSelector 获取保留的对象，我不确定最佳实践是什么 - 除了“不要这样做”。

Answer 13

@c-road 提供了带有问题描述的正确链接 这里。下面您可以看到我的示例，当performSelector 导致内存泄漏时。

@interface Dummy : NSObject <NSCopying>
@end

@implementation Dummy

- (id)copyWithZone:(NSZone *)zone {
  return [[Dummy alloc] init];
}

- (id)clone {
  return [[Dummy alloc] init];
}

@end

void CopyDummy(Dummy *dummy) {
  __unused Dummy *dummyClone = [dummy copy];
}

void CloneDummy(Dummy *dummy) {
  __unused Dummy *dummyClone = [dummy clone];
}

void CopyDummyWithLeak(Dummy *dummy, SEL copySelector) {
  __unused Dummy *dummyClone = [dummy performSelector:copySelector];
}

void CloneDummyWithoutLeak(Dummy *dummy, SEL cloneSelector) {
  __unused Dummy *dummyClone = [dummy performSelector:cloneSelector];
}

int main(int argc, const char * argv[]) {
  @autoreleasepool {
    Dummy *dummy = [[Dummy alloc] init];
    for (;;) { @autoreleasepool {
      //CopyDummy(dummy);
      //CloneDummy(dummy);
      //CloneDummyWithoutLeak(dummy, @selector(clone));
      CopyDummyWithLeak(dummy, @selector(copy));
      [NSThread sleepForTimeInterval:1];
    }} 
  }
  return 0;
}

在我的示例中导致内存泄漏的唯一方法是 CopyDummyWithLeak。原因是 ARC 不知道，copySelector 返回保留的对象。

如果您运行内存泄漏工具，您可以看到下图：

...并且在任何其他情况下都没有内存泄漏：

Answer 14

不要压制警告！

修补编译器的替代解决方案不少于 12 个。
虽然你在第一次实现时很聪明，但地球上很少有工程师能够追随你的脚步，并且这段代码最终会被破坏。

安全路线：

所有这些解决方案都会起作用，但与您的初衷存在一定程度的差异。如果您愿意，假设 param 可以为 nil：

安全路线，相同的概念行为：

// GREAT
[_controller performSelectorOnMainThread:selector withObject:anArgument waitUntilDone:YES];
[_controller performSelectorOnMainThread:selector withObject:anArgument waitUntilDone:YES modes:@[(__bridge NSString *)kCFRunLoopDefaultMode]];

[_controller performSelector:selector onThread:[NSThread mainThread] withObject:anArgument waitUntilDone:YES];
[_controller performSelector:selector onThread:[NSThread mainThread] withObject:anArgument waitUntilDone:YES modes:@[(__bridge NSString *)kCFRunLoopDefaultMode]];

安全路线，略有不同的行为：< /strong>

（请参阅此回复）
使用任何线程代替[NSThread mainThread]。

// GOOD
[_controller performSelector:selector withObject:anArgument afterDelay:0];
[_controller performSelector:selector withObject:anArgument afterDelay:0 inModes:@[(__bridge NSString *)kCFRunLoopDefaultMode]];

[_controller performSelectorOnMainThread:selector withObject:anArgument waitUntilDone:NO];
[_controller performSelectorOnMainThread:selector withObject:anArgument waitUntilDone:NO];
[_controller performSelectorOnMainThread:selector withObject:anArgument waitUntilDone:NO modes:@[(__bridge NSString *)kCFRunLoopDefaultMode]];

[_controller performSelectorInBackground:selector withObject:anArgument];

[_controller performSelector:selector onThread:[NSThread mainThread] withObject:anArgument waitUntilDone:NO];
[_controller performSelector:selector onThread:[NSThread mainThread] withObject:anArgument waitUntilDone:NO modes:@[(__bridge NSString *)kCFRunLoopDefaultMode]];

---

危险路线

需要某种编译器静默，这必然会被破坏。请注意，目前，它确实在Swift中中断。

// AT YOUR OWN RISK
[_controller performSelector:selector];
[_controller performSelector:selector withObject:anArgument];
[_controller performSelector:selector withObject:anArgument withObject:nil];

Answer 15

为了使 Scott Thompson 的宏更通用：

// String expander
#define MY_STRX(X) #X
#define MY_STR(X) MY_STRX(X)

#define MYSilenceWarning(FLAG, MACRO) \
_Pragma("clang diagnostic push") \
_Pragma(MY_STR(clang diagnostic ignored MY_STR(FLAG))) \
MACRO \
_Pragma("clang diagnostic pop")

然后像这样使用它：

MYSilenceWarning(-Warc-performSelector-leaks,
[_target performSelector:_action withObject:self];
                )

Answer 16

由于您使用的是 ARC，因此您必须使用 iOS 4.0 或更高版本。这意味着您可以使用块。如果您不记住要执行的选择器，而是选择一个块，ARC 将能够更好地跟踪实际发生的情况，并且您不必冒意外引入内存泄漏的风险。

Answer 17

我不使用块方法，这给我带来了一些问题：

    IMP imp = [_controller methodForSelector:selector];
    void (*func)(id, SEL) = (void *)imp;

我将使用 NSInitation，如下所示：

    -(void) sendSelectorToDelegate:(SEL) selector withSender:(UIButton *)button 

    if ([delegate respondsToSelector:selector])
    {
    NSMethodSignature * methodSignature = [[delegate class]
                                    instanceMethodSignatureForSelector:selector];
    NSInvocation * delegateInvocation = [NSInvocation
                                   invocationWithMethodSignature:methodSignature];


    [delegateInvocation setSelector:selector];
    [delegateInvocation setTarget:delegate];

    // remember the first two parameter are cmd and self
    [delegateInvocation setArgument:&button atIndex:2];
    [delegateInvocation invoke];
    }

Answer 18

如果您不需要传递任何参数，一个简单的解决方法是使用 valueForKeyPath。这甚至在 Class 对象上也是可能的。

NSString *colorName = @"brightPinkColor";
id uicolor = [UIColor class];
if ([uicolor respondsToSelector:NSSelectorFromString(colorName)]){
    UIColor *brightPink = [uicolor valueForKeyPath:colorName];
    ...
}

Answer 19

您还可以在此处使用协议。因此，创建一个像这样的协议：

@protocol MyProtocol
-(void)doSomethingWithObject:(id)object;
@end

在需要调用选择器的类中，您有一个@property。

@interface MyObject
    @property (strong) id<MyProtocol> source;
@end

当您需要在 MyObject 实例中调用 @selector(doSomethingWithObject:) 时，请执行以下操作：

[self.source doSomethingWithObject:object];