全局变量与类递归和开销

I'm building an app based on an existing MVC framework.

The native app bootstraps up by creating a registry object, then populates it with all the classes needed, which is great.

$registry = new \App\Registry;

$loader = new \App\Loader;
$registry->set('load', $loader);

But when a descendant class needs access to the registry or another instantiated object, they're passing in the registry object and setting it as variable in the object of the new class.

$theme = new \App\Theme($registry);
$registry->set('theme', $theme);

Then inside the theme class:

class Theme {

   private $registry;

   public function __construct($registry) {
      $this->registry = $registry;
   }
}

This is creating recursion on each instance and by the time the app gets to the front controller class, it's this huge bloated object with massive recursion that's completely unnecessary.

I know that using global variables is frowned upon, and I don't use them unless absolutely needed, but is it not much more efficient to simply call the registry object as a global only where it's needed so as to not have all this bloat?

My solution is to just call the registry as a global within the method in a given class where I need to access an object that's already been registered.

For instance in my example, let's say I need to access the loader object from within a method in Theme.

class Theme {

   public function __construct() {
      $this->setName();
   }

   public function setName() {
      global $registry;

      $loader = $registry->get('load');
      $loader->setName();
   }
}

This removes the need to set the registry as a variable inside theme, so that each object is only created once.

Is there anything wrong with this approach? Are there security issues? Is there another technique that would produce the result I want without using a global reference?