[G3 Q&A, Help & Troubleshooting] iBolski:
Greenify is not a task killer. What it does is it "hibernates" an app, keeping it from starting up in the background. It's very akin to freezing an app with one exception - the app that is hibernated can be launched again, whereas an app that is frozen must be unfrozen before it can be launched.

Task killer go and kill an app process outright. This is bad for a number of reasons. It requires an understanding of the Android App life cycle. I don't want to get into details, but unfortunately, that's very hard to do when talking about Android application lifecycle.

So, be prepared.

In android, there are various "stages" an Android app (activity is what it's really called) goes through:

onCreate - This gets called when an app is being launched for the first time (after reboot, after initial install, after it's been killed and is no longer "paused").

onStart - This is the starting phase when the app starts.

onResume - This runs after onStart, but also can happen if the app has been paused (such as switching to another app, screen rotation, going back to the home screen). This is how an app can retrieve the last state it was in when it was paused.

onPause - This occurs when an app is paused. This could be because the user switch to another app, went to the home screen, the screen was rotated, etc. This is where the app will save certain settings so it can "resume" back to the point it was last at.

onStop - This is where the app will undo all that was done in the onCreate phase. This gets called when an app (more specifically an activity) is about to get destroyed. In the case of task killers, this will get called when the task killer kills your app's process.

onDestroy - This is the final stage of destroying an app process from memory. If this stage is reached, then the next time the app is launched, it will have to start from the onCreate stage to the onStart, onResume all over again.

So, Task Killers will cause an app to have to start the entire Android app life cycle over again from the beginning (onCreate -> onStart). This requires more time, more resources and eats up battery life.

However, if an app is allowed to not be killed, when it's paused, the next time you run the app, as long as the Android OS has not deemed that it's low on resources and has killed the app itself, it will start at the onResume stage again. This is how Greenify works. It doesn't kill an app. It just hibernates it (keeps it in an onPaused state).

So, basically, if you have an app that you started for the first time, switched to another app, and then switched back, this is what would happen:

First app:

onCreate -> onStart -> onResume -> onPause (this part happens when you switch to the new app)

Second app:

onCreate -> onStart - > on Resume -> onPause (this part happens when you switch back to the previous app)

^-- This will only happen if the second app hasn't already been launched and paused.

First app:

onResume

From there, it will go back to onPause if you switch to another app. The Android OS monitors resources and if it deems it's running low, it will look for processes/apps/activities that haven't been running for a long time and it will kill those which would then cause them to the go the onStop->onDestroy stages, but ONLY if it deems it necessary.

Again, going through the onCreate->onStart is more intensive then restarting from the onResume stage. Usually, an app has to load up various settings, allocate resources, etc. This is done usually in the onCreate and onStart stages. From there, those parts shouldn't be needed in onResume. Of course, if someone has written an app poorly, it may not matter whether you kill it or pause it. That's why there are some apps that behave poorly due to how they were written. Some people try to write android apps as if they are like PC software. PC software and architecture is completely different from Android. PCs have more resources (memory) and usually do not have to worry about battery life (except with laptops).

Android devices are smaller, have less resources (memory, storage) and rely on battery and therefore, the OS has to manage applications and resources differently than a PC program. Yet, until someone truly understands the Android activity life cycle, if they program an application without regards to the life cycle, then the app can behave poorly, suck up resources, which ends up eating up battery life.

Android applications should have a limited life span. Do what you need and then pause. Having an application running constantly will drain the battery.

Hopefully that helps you understand the difference between a task killer and Greenify.