cell documentation page有相当好的例子。Rust总是试图保护你不做坏事（比如对同一个东西有两个可变引用）。因此，它不像使用Rust的内置引用那么“容易”，因为你需要做运行时检查（Rust引用在编译时检查）。
RefCell类型就是为此而存在的。它在运行时检查可变性规则。你会得到一些内存和计算时间开销，但你最终会得到Rust在编译时检查中承诺的内存安全。
移植到RefCell的示例如下所示。

use std::cell::RefCell;

struct Player {
    points: i32,
}

// the lifetime is still needed to guarantee that Resources
// don't outlive their player
struct Resource<'a> {
    owner: &'a RefCell<Player>,
}

impl<'a> Resource<'a> {
    fn test(&self) -> i32 {
        self.owner.borrow().points
    }
}

fn main() {
    let player = RefCell::new(Player { points: 0 });
    let mut resources = Vec::new();
    resources.push(Resource { owner: &player });
    player.borrow_mut().points = 30;
    println!("{:?}", resources[0].test());
}

字符串
我关心的是，如果我尝试用Rust编写Java代码，它能以Rust的方式完成而不牺牲编译时安全性吗？完全避免共享可变状态？
你并没有牺牲编译时的安全性。Rust确保（在编译时）你正确地使用了你的库。但是，如果你使用borrow*函数，你的程序可能会在运行时“panic”。如果你使用try_borrow*函数，你可以检查它是否成功，如果没有，做一些回退操作。
你也可以使用一个RefCell类型的引用计数框（Rc<RefCell<Player>>）。然后你只需要确保你没有创建循环，否则你的内存将永远不会被释放。这将更像Java（尽管Java会自动找到循环）。

每个资源可以由一个玩家拥有。
然后让类型执行此操作：

struct Player {
    points: i32,
    resources: Vec<Resource>,
}

struct Resource {
    gold: i32,
}

fn main() {
    let player1 = Player {
        points: 30,
        resources: vec![Resource { gold: 54 }],
    };
    let player2 = Player {
        points: 50,
        resources: vec![Resource { gold: 99 }],
    };

    // If you really need an array of all the resources...
    // Although this seems like you should just ask the Player to do something
    let mut resources: Vec<_> = vec![];
    resources.extend(player1.resources.iter());
    resources.extend(player2.resources.iter());
}

字符串

编辑感谢@ziggystar指出我的原始版本只允许玩家拥有一个Resource。现在玩家可以拥有N个资源，但他们仍然是一个资源的唯一所有者。

这是一个常见的问题，Rc<RefCell<T>>是一个常见的答案。它在小示例中工作正常，或者当你只需要一点点共享时。但是当你的程序状态是一个有循环的图时，Rc往往会导致内存泄漏，RefCell往往会在运行时死机。你失去了一些你期望从Rust得到的编译时正确性，而且它也是令人痛苦的冗长。这在游戏中尤其是个问题。
对于游戏和一般具有图/关系状态的程序来说，一个更好的方法是使用索引而不是引用。你的例子可能看起来像这样（我将避免假设每个资源都被一个玩家唯一引用，以使解决方案更通用）：

struct Player {
    resource_ids: Vec<usize>,
    points: i32,
}

struct Resource {
    owner_id: usize,
}

struct GameState {
    players: Vec<Player>,
    resources: Vec<Resource>,
}

fn new_player(state: &mut GameState) -> usize {
    state.players.push(Player { points: 0, resource_ids: Vec::new() });
    state.players.len() - 1
}

fn new_resource(state: &mut GameState, owner_id: usize) -> usize {
    state.resources.push(Resource { owner_id });
    let new_id = state.resources.len() - 1;
    state.players[owner_id].resource_ids.push(new_id);
    state.players[owner_id].points += 30;
    new_id
}

fn main() {
    let mut state = GameState { players: Vec::new(), resources: Vec::new() };
    let player_id = new_player(&mut state);
    let resource_id = new_resource(&mut state, player_id);
}

字符串
编写游戏是一个很深的主题，我们可以用很多方法来扩展这个例子。我们可能需要为Player和Resource使用不同的索引类型，而不是为所有内容使用usize，这样我们就不会把它们弄混了。如果我们需要支持删除，我们可能想用HashMap来代替Vec。但这只是一个开始。参见Using Rust For Game Development和Object Soup is Made of Indexes。