What ARC does at compile time and runtime

In addition to automatically calling the "retain" and "release" methods, there are other benefits of using ARC, which can perform optimizations that are difficult or impossible to do manually.
At compile time, ARC will reduce the operations of retain, release, autorelease that can cancel each other.If it finds that multiple "retain" and "release" operations are performed on the same object, then ARC can sometimes remove the two operations in pairs.ARC will analyze the object's lifetime requirements and automatically insert code for appropriate memory management method calls at compile time, without requiring you to remember when to use retain, release, autorelease method.The compiler will also generate the appropriate dealloc methods for you.
Delegating memory management to the compiler and run-time components allows for a variety of code optimizations.For example, ARC can detect at runtime the redundant pair of autorelease followed by retain.To optimize the code, a special function is executed when an autoreleased object is returned in a method.

Some Q&A

• How should I view ARC?Where does it put the code called by retains/releases ?

  Try not to think about where ARC puts the code called by retains/releases, but think about the application algorithm, think about the strong and weak pointers, ownership, and possible circular references.

• Do I still need to write a dealloc method for my object?

  Sometimes needed.Because ARC does not automatically handle malloc/free, lifecycle management of Core Foundation objects, file descriptors, etc., you can still write dealloc method to release these resources.You don't have to (actually can't) free instance variables, but you may need to call [self setDelegate:nil] on system classes and other code not written with ARC.The dealloc method under ARC does not need and is not allowed to call [super dealloc], and Runtime will handle it automatically.

• Are circular references still possible in ARC?

  Yes, ARC automatically retain/release also inherits the circular reference problem.Fortunately, code migrating to ARC rarely starts leaking because the property already declares whether or not to retain.

How does
• block work in ARC?

  Under ARC, the compiler will automatically copy the block on the stack to the heap according to the situation, such as when block is used as the return value of the function, so you don't have toInvoke Block Copy.
  One thing to note is that under ARC, NSString * __block myString is written like this, block will be strong on the NSString objectreference instead of causing the dangling pointer problem.If you want to be consistent with MRC, use __block NSString * __unsafe_unretained myString or (better yet) use __block NSString * __weak myString.

• Is ARC slow?

  No.The compiler has effectively eliminated many extraneous retain/release calls, and has put a lot of effort into speeding up the Objective-C runtime.In particular, when the caller of the method is ARC code, the common "return a retain/autoreleased object" pattern is much faster and doesn't actually put the object into the autoreleased pool.