Caché de compilación y daemon

Ever waited too long for a Gradle build to finish? In this lesson, we'll unlock two powerful features to speed up your development:

• Gradle Daemon: Keeps a JVM running in the background.
• Build Cache: Reuses outputs from previous builds.

These tools are essential for making your incremental builds much faster!

The Gradle Daemon is a long-lived background process that hosts your Gradle builds. Think of it like a dedicated server for your builds!

• It eliminates the JVM startup overhead for each build.
• It keeps project information and caches in memory.
• This means subsequent builds are significantly faster!

Let's see the Daemon's effect. The first time you run a Gradle command, the Daemon might need to start up, taking a bit longer. Copy this into a build.gradle file:

Now, run the task again using gradle greet. Notice how much faster it is? That's the Daemon at work!

You can check if the Daemon is running with gradle --status and stop it with gradle --stop.

The Gradle Build Cache stores the outputs of tasks that have been executed. If a task's inputs haven't changed, Gradle can reuse its cached output instead of re-running it.

• It saves time by avoiding redundant work.
• Works across different machines if a remote cache is configured.
• Enabled by default for local caching.

The local build cache is stored on your machine, typically in your Gradle user home directory (~/.gradle/caches/build-cache).

When a task runs, Gradle calculates a hash of its inputs. If that hash matches an entry in the cache, the cached output is used. If not, the task runs and its output is stored.

For a task to be cacheable, it must properly declare its inputs and outputs. Gradle needs to know what goes into a task and what comes out to determine if it can be cached.

• Inputs: Files, properties, directories used by the task.
• Outputs: Files or directories produced by the task.

Many built-in Gradle tasks (like compileJava) are cacheable by default!

Let's create a task that generates a file. Run gradle generateReport once, then run it again. Notice FROM-CACHE or UP-TO-DATE in the output!

Sometimes, the build cache might not be used, leading to a "cache miss". Common reasons include:

• Input Changes: Any change to task inputs (even a timestamp).
• Task Not Cacheable: Task doesn't properly declare inputs/outputs.
• Cache Disabled: Explicitly disabled with --no-build-cache.
• Local Cache Cleaned: Cache entries removed.

What is the primary benefit of the Gradle Daemon?

You've learned how the Gradle Daemon and Build Cache significantly improve build performance:

• The Daemon keeps a JVM running, making subsequent builds start faster.
• The Build Cache reuses previous task outputs, avoiding redundant work.

By leveraging these, you can enjoy much quicker incremental builds and a smoother development workflow. Next, we'll explore profiling and debugging your builds!