Question: What is difference between.
what is best?
Do you **drain** same **release** but different in drain don't save **retain**, while release save retain?
**autorelease** save object in memory some time.

Answer: 
What is best? The answer, of course, is 'it depends'.

For most newcomers to Cocoa, my opinion is 'none of the above' - it is ARC. Although even with ARC, some understanding of reference-counted memory management is important, you need not worry about missing a `release` or `autorelease`, over over-releasing.

In the situation described by @Anshuk Garg above where you are creating numerous temporary objects before the thread's autorelease pool would be drained, you can wrap the code in question in an `@autorelease { ... }` block. Instruments can tell you whether your memory footprint is an issue in these settings.
**release**:
In a reference-counted environment, since an autorelease pool cannot be retained , this method decrements the retain count. When an autorelease pool is deallocated, it sends a 'release' message to all its autoreleased objects. Also, In a garbage-collected environment, this method is a no no.

```
- (void)release

```

**drain**:
In a reference-counted environment, releases and pops the receiver; in a garbage-collected environment, triggers garbage collection if the memory allocated since the last collection is greater than the current threshold.

```
- (void)drain

```

Conclusion:
From the above brief discussion it is clear that, we should always use 'drain' over 'release' for an autorelease pool(be the Cocoa or Cocoa touch).

**release vs autorelease**
In most cases, it wont really matter either way. Since -autorelease simply means that the object will be released at the end of the current iteration of the run loop, the object will get released either way.

The biggest benefit of using -autorelease is that you don't have to worry about the lifetime of the object in the context of your method. So, if you decide later that you want to do something with an object several lines after it was last used, you don't need to worry about moving your call to -release.

The main instance when using -release will make a noticeable difference vs. using -autorelease is if you're creating a lot of temporary objects in your method.