我有以下内容：

use std::collections::HashMap;
use std::*;

fn main() {
    let mut struct_a: struct_A = struct_A::new();
    loop {
        let _res = struct_a.process();
    }
}

pub struct struct_A<'a> {
    pub entities: struct_B<'a>,
}

impl<'a> struct_A<'a> {
    pub fn new() -> struct_A<'a> {
        let mut struct_A: struct_A = struct_A {
            entities: struct_B::new(),
        };

        struct_A
    }

    pub fn process(&mut self) -> Result<(), String> {
        self.entities.get_connection(832);
        Ok(())
    }
}

pub struct struct_B<'a> {
    chain: Chain<u32, struct_c<'a>>,
}

pub struct struct_c<'a> {
    // other fields here
    u: &'a u32,
}

impl<'a> struct_B<'a> {
    pub fn new() -> Self {
        let cache = HashMap::new();
        struct_B {
            chain: Chain::<u32, struct_c>::new(cache),
        }
    }

    pub fn get_connection(&self, mac: u32) -> Option<&'a mut Node<struct_c>> {
        self.chain.find(mac)
    }
}

pub struct Chain<K, V> {
    pub cache: HashMap<K, *mut Node<V>>,
}

#[derive(Default)]
pub struct Node<T> {
    pub data: T,
}

impl<K, V> Chain<K, V>
where
    K: std::cmp::Eq + std::hash::Hash,
{
    pub fn new(pool: HashMap<K, *mut Node<V>>) -> Self {
        Chain { cache: pool }
    }

    pub fn find(&self, key: K) -> Option<&mut Node<V>> {
        if let Some(node) = self.cache.get(&key) {
            unsafe {
                return Some(node.as_mut().unwrap());
            }
        }
        None
    }
}

编译，我得到：

error[E0499]: cannot borrow `struct_a` as mutable more than once at a time
 --> src/main.rs:7:20
  |

当我编译时，我得到：

--> src/main.rs:25:9
   |
15 | impl<'a> struct_A<'a> {
   |      -- lifetime `'a` defined here
...
24 |     pub fn process(&mut self) -> Result<(), String> {
   |                    - let's call the lifetime of this reference `'1`
25 |         self.entities.get_connection(832);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ argument requires that `'1` must outlive `'a`

如果我给process()加上生命周期，就像这样：

pub fn process<'b>(&'b mut self) -> Result<(), String>
    where
        'b: 'a,
    {
        self.entities.get_connection(832);
        Ok(())
    }

编译，我得到：

error[E0499]: cannot borrow `struct_a` as mutable more than once at a time
 --> src/main.rs:7:20
  |
7 |         let _res = struct_a.process();
  |                    ^^^^^^^^^^^^^^^^^^
  |                    |
  |                    `struct_a` was mutably borrowed here in the previous iteration of the loop
  |                    first borrow used here, in later iteration of loop

我真的很难理解为什么我得到了原来的编译错误，开始，我认为这与variance有关，但我不确定到底是什么。