diff --git a/pathauto.admin.inc b/pathauto.admin.inc
index b210386..4083d94 100644
--- a/pathauto.admin.inc
+++ b/pathauto.admin.inc
@@ -203,6 +203,13 @@ function pathauto_settings_form($form) {
     );
   }
 
+  $form['pathauto_entity_update_alias_queue_process_on_cron'] = array(
+    '#type' => 'checkbox',
+    '#title' => t('Process the entity alias update queue during normal cron runs.'),
+    '#description' => t('If this is disabled, you are responsible for managing the queue some other way. Pathauto depends on the queue to update taxonomy term aliases when parent terms are updated.'),
+    '#default_value' => variable_get('pathauto_entity_update_alias_queue_process_on_cron', TRUE),
+  );
+
   return system_settings_form($form);
 }
 
diff --git a/pathauto.module b/pathauto.module
index be085fb..4b71821 100644
--- a/pathauto.module
+++ b/pathauto.module
@@ -704,12 +704,21 @@ function pathauto_taxonomy_term_update_alias(stdClass $term, $op, array $options
   $uri = entity_uri('taxonomy_term', $term);
   $result = pathauto_create_alias($module, $op, $uri['path'], array('term' => $term), $term->vocabulary_machine_name, $options['language']);
 
+  // Enqueue the update of the aliases of this term's child terms if specified.
   if (!empty($options['alias children'])) {
-    // For all children generate new aliases.
-    $options['alias children'] = FALSE;
     unset($options['language']);
-    foreach (taxonomy_get_tree($term->vid, $term->tid) as $subterm) {
-      pathauto_taxonomy_term_update_alias($subterm, $op, $options);
+
+    if ($children = taxonomy_get_children($term->tid)) {
+      foreach (array_keys($children) as $child_tid) {
+        pathauto_entity_update_alias_enqueue('taxonomy_term', $child_tid, $op, $options);
+      }
+    }
+  }
+
+  // Enqueue the update of the aliases of nodes that reference this term.
+  if ($nids = taxonomy_select_nodes($term->tid)) {
+    foreach ($nids as $nid) {
+      pathauto_entity_update_alias_enqueue('node', $nid, $op);
     }
   }
 
@@ -828,6 +837,21 @@ function pathauto_user_update_alias(stdClass $account, $op, array $options = arr
     pathauto_blog_update_alias($account, $op, $options);
   }
 
+  // Since nodes have access to user related tokens, also update the aliases for
+  // all nodes created by this user.
+  $query = new EntityFieldQuery;
+  $query
+    ->entityCondition('entity_type', 'node')
+    ->propertyCondition('uid', $account->uid);
+
+  $results = $query->execute();
+
+  if (!empty($results['node'])) {
+    foreach (array_keys($results['node']) as $nid) {
+      pathauto_entity_update_alias_enqueue('node', $nid, $op);
+    }
+  }
+
   return $return;
 }
 
@@ -895,3 +919,146 @@ function pathauto_blog_update_alias(stdClass $account, $op, array $options = arr
 /**
  * @} End of "name pathauto_user".
  */
+
+/**
+ * @name pathauto_entity Pathauto integration for queued entity alias updates.
+ * @{
+ */
+
+/**
+ * Implements hook_entity_info_alter().
+ */
+function pathauto_entity_info_alter(&$entity_info) {
+  // Add the Pathauto alias update callbacks defined in this module, preserving
+  // any that may have already been set.
+  foreach (array('node', 'taxonomy_term', 'user') as $entity_type) {
+    if (empty($entity_info[$entity_type]['pathauto alias update callback'])) {
+      $entity_info[$entity_type]['pathauto alias update callback'] = 'pathauto_' . $entity_type . '_update_alias';
+    }
+  }
+}
+
+/**
+ * Returns the callback used to update an entity type's path aliases.
+ *
+ * @param $entity_type
+ *   The machine-name of the entity type whose callback should be returned.
+ *
+ * @return string|bool
+ *   The name of the callback used to update the entity type's path aliases or
+ *   FALSE if the callback is unknown or does not exist.
+ */
+function pathauto_entity_path_alias_update_callback($entity_type) {
+  // Look for a Pathauto alias update callback in the entity type's info array.
+  $info = entity_get_info($entity_type);
+
+  if (!empty($info['pathauto alias update callback'])) {
+    $callback = $info['pathauto alias update callback'];
+
+    // Ensure the function exists before returning it.
+    if (function_exists($callback)) {
+      return $callback;
+    }
+  }
+
+  // If we don't know the name of the callback or the specified callback
+  // function did not exist, return FALSE.
+  return FALSE;
+}
+
+/**
+ * Updates an entity's path alias.
+ *
+ * @param $entity_type
+ *   The machine-name of the entity type.
+ * @param $entity_id
+ *   The ID of the entity whose alias should be updated.
+ * @param $op
+ *   The triggering operation performed on the entity ('insert', 'update' or
+ *   'bulkupdate').
+ * @param $options
+ *   An optional array of additional options that vary by entity type.
+ *
+ * @return array|null|bool
+ *   The alias array that was created, NULL if an empty alias was generated, or
+ *   FALSE if the alias generation was not possible.
+ */
+function pathauto_entity_update_alias($entity_type, $entity_id, $op, array $options = array()) {
+  // Attempt to load the entity whose path alias should be updated.
+  $entities = entity_load($entity_type, array($entity_id));
+
+  // Do nothing if it no longer exists.
+  if (empty($entities)) {
+    return FALSE;
+  }
+
+  $entity = reset($entities);
+
+  // Request and invoke the callback used to update aliases of the entity type.
+  if ($callback = pathauto_entity_path_alias_update_callback($entity_type)) {
+    return $callback($entity, $op, $options);
+  }
+
+  return FALSE;
+}
+
+/**
+ * Enqueues the update of a single entity's path alias.
+ */
+function pathauto_entity_update_alias_enqueue($entity_type, $entity_id, $op, $options = array()) {
+  // Load a reliable queue used to manage updating entity path aliases.
+  $queue = DrupalQueue::get('pathauto_entity_update_alias', TRUE);
+
+  // Prepare an item's data array and add it to the queue.
+  $data = array(
+    'entity_type' => $entity_type,
+    'entity_id' => $entity_id,
+    'op' => $op,
+    'options' => $options,
+  );
+  $queue->createItem($data);
+}
+
+/**
+ * Implements hook_cron_queue_info().
+ */
+function pathauto_cron_queue_info() {
+  return array(
+    'pathauto_entity_update_alias' => array(
+      'worker callback' => 'pathauto_entity_update_alias_queue_worker',
+      'time' => 60,
+      'skip on cron' => !variable_get('pathauto_entity_update_alias_queue_process_on_cron', TRUE),
+    ),
+  );
+}
+
+/**
+ * Processes a single item from the pathauto_entity_update_alias queue.
+ *
+ * @param array $data
+ *   The data array from the queue; should contain keys matching the parameters
+ *   of pathauto_entity_alias_update_alias() with values sufficient to update
+ *   the path alias of a single entity.
+ *
+ * @see pathauto_entity_update_alias()
+ */
+function pathauto_entity_update_alias_queue_worker($data) {
+  // If the current item doesn't have all of the necessary data on it, do not
+  // attempt to process it. The caller is responsible for deleting the item from
+  // the queue after calling this worker callback unless this function throws an
+  // exception. Note that the options array is optional and can safely be
+  // defaulted to an empty array if the queue item did not specify it.
+  if (empty($data['entity_type']) || empty($data['entity_id']) || empty($data['op'])) {
+    return;
+  }
+
+  // Set a default options array if necessary.
+  $data += array('options' => array());
+
+  // Update the alias of the entity.
+  pathauto_entity_update_alias($data['entity_type'], $data['entity_id'], $data['op'], $data['options']);
+}
+
+/**
+ * @} End of "name pathauto_entity".
+ */
diff --git a/pathauto.test b/pathauto.test
index 5a408e0..192dfcb 100644
--- a/pathauto.test
+++ b/pathauto.test
@@ -306,6 +306,39 @@ class PathautoUnitTestCase extends PathautoTestHelper {
     $this->assertEntityAlias('taxonomy_term', $term2, 'My Crazy/Alias/child-term');
   }
 
+  /**
+   * Test the processing of the path alias update queue.
+   */
+  function testEntityPathAliasUpdateQueue() {
+    variable_set('pathauto_taxonomy_term_pattern', '[term:parents]/[term:name]');
+    $vocab = $this->addVocabulary();
+
+    $term1 = $this->addTerm($vocab, array('name' => 'Parent term'));
+    $this->assertEntityAlias('taxonomy_term', $term1, 'parent-term');
+
+    $term2 = $this->addTerm($vocab, array('name' => 'Child term', 'parent' => $term1->tid));
+    $this->assertEntityAlias('taxonomy_term', $term2, 'parent-term/child-term');
+
+    $term3 = $this->addTerm($vocab, array('name' => 'Another child term', 'parent' => $term2->tid));
+    $this->assertEntityAlias('taxonomy_term', $term3, 'parent-term-child-term/another-child-term');
+
+    // Update the parent term to queue a cascading update to its child term.
+    $term1->name = 'Parent term updated';
+    taxonomy_term_save($term1);
+
+    // First ensure the queue is not processed on cron if disabled.
+    variable_set('pathauto_entity_update_alias_queue_process_on_cron', FALSE);
+    $this->cronRun();
+    $this->assertEntityAlias('taxonomy_term', $term2, 'parent-term/child-term');
+    $this->assertEntityAlias('taxonomy_term', $term3, 'parent-term-child-term/another-child-term');
+
+    // Then ensure the queue is processed on cron if enabled.
+    variable_set('pathauto_entity_update_alias_queue_process_on_cron', TRUE);
+    $this->cronRun();
+    $this->assertEntityAlias('taxonomy_term', $term2, 'parent-term-updated/child-term');
+    $this->assertEntityAlias('taxonomy_term', $term3, 'parent-term-updated-child-term/another-child-term');
+  }
+
   function testEntityBundleRenamingDeleting() {
     // Create a vocabulary and test that it's pattern variable works.
     $vocab = $this->addVocabulary(array('machine_name' => 'old_name'));