Database Rust无法打开数据库

您好，我正在进行区块链实施，我的一切都正常工作，但现在我无法挖掘区块，我将解释程序是如何工作的 它使用2个数据库来创建块 在block中，他得到了2个数据库的最后一个哈希值，它工作得非常好，直到我得到这个错误，我已经尝试了所有的方法！它无法打开数据库错误：

无法获取“data2/blocks/db”上的锁

我得到了处理cmd的2个func 1st：

fn cmd_send(from: &str, to: &str, amount: i32, mine_now: bool, chain: i32) -> Result<()> {



    let wallets = Wallets::new()?;
    let wallet = wallets.get_wallet(from).unwrap();

    if mine_now {
        match chain {
            2 => {
            // handle chain 2
            let bc = Blockchain::new2()?;
            let mut utxo_set1 = UTXOSet { blockchain: bc };
            let tx1 = Transaction::new_UTXO(wallet, to, amount, &utxo_set1)?;

            println!("Sending to chain 2");
            let cbtx = Transaction::new_coinbase(from.to_string(), String::from("reward!"))?;
            let new_block = utxo_set1.blockchain.mine_block(vec![cbtx, tx1],2)?;
            utxo_set1.update(&new_block,2)?;
            println!("success!");
            }
            1 => {
            let bc = Blockchain::new()?;
            let mut utxo_set = UTXOSet { blockchain: bc };
            // handle chain 1
            let tx = Transaction::new_UTXO(wallet, to, amount, &utxo_set)?;

            println!("Sending to chain 1");
            let cbtx = Transaction::new_coinbase(from.to_string(), String::from("reward!"))?;
            let new_block = utxo_set.blockchain.mine_block(vec![cbtx, tx],1)?;
            utxo_set.update(&new_block,1)?;
            println!("success!");
            }_ => {
               println!("Unknown chain index: {}", chain);
            }
         
 };
 

fn cmd\u send（from:&str，to:&str，金额：i32，我的现在：bool，chain:i32）->结果{
让钱包=钱包：：新（）？；
let wallet=钱包。从中取出钱包。展开（）；
如果我的现在是你{
火柴链{
2 => {
//把手链2
设bc=Blockchain:：new2（）？；
让mut utxo_set1=UTXOSet{区块链：bc}；
让tx1=交易：：新的UTXO（钱包、收件人、金额和UTXO设置1）？；
println！（“发送到链2”）；
让cbtx=Transaction:：new_coinbase（from.to_string（），string:：from（“奖励”）？；
让new_block=utxo_set1.区块链.mine_block（vec！[cbtx，tx1]，2）？；
utxo_设置1.更新（&新_块，2）？；
println！（“成功！”）；
}
1 => {
设bc=区块链：：new（）？；
设mut utxo_set=UTXOSet{blockchain:bc}；
//把手链条1
let tx=交易：：新的UTXO（钱包、收件人、金额和UTXO集合）？；
println！（“发送到链1”）；
让cbtx=Transaction:：new_coinbase（from.to_string（），string:：from（“奖励”）？；
让new_block=utxo_set.blockchain.mine_block（vec！[cbtx，tx]，1）？；
utxo_集更新（&新_块，1）？；
println！（“成功！”）；
}_ => {
println！（“未知链索引：{}”，链）；
}
};

我得到了我的函数：

    pub fn mine_block(&mut self, transactions: Vec<Transaction>, chain: i32) -> Result<Block> {
        println!("mine a new block");
        for tx in &transactions {
            if !self.verify_transacton(tx)? {
                return Err(format_err!("ERROR: Invalid transaction"));
            }
        }

        let Header = match chain {
            1 => "Chain 1",
            2 => "Chain 2",
            _ => panic!("Unknown chain index!")
        };
        
        let wchain = match chain {
            1 => "data2/blocks",
            2 => "data/blocks",
            _ => panic!("Unknown chain index!")
        };
        let wchain1 = match chain {
            2 => "data2/blocks",
            1 => "data/blocks",
            _ => panic!("Unknown chain index!")
        };

        let db1 = sled::open(wchain)?;
        let db = sled::open(wchain1)?;

        println!("mine a new block 11");


        println!("mine a new block 1");

       
        let lasthash = self.db.get("LAST")?.unwrap();
        println!("mine a new block 2");

        let lasthash1 = db.get("LAST")?.unwrap();
        println!("mine a new block 3");

        let newblock = Block::new_block(
            transactions,
            String::from_utf8(lasthash.to_vec())?,
            String::from_utf8(lasthash1.to_vec())?,
            String::from(Header),
            self.get_best_height(chain)? + 1,
        )?;
        println!("mine a new block 4");

        match chain {
            1 => {
                self.db.insert(newblock.get_hash(), serialize(&newblock)?)?;
                self.db.insert("LAST", newblock.get_hash().as_bytes())?;
                self.db.flush()?;
            }
            2 => {
                db1.insert(newblock.get_hash(), serialize(&newblock)?)?;
                db1.insert("LAST", newblock.get_hash().as_bytes())?;
                db1.flush()?;

            }
            _ => panic!("Unknown chain index!")
        };



        self.tip = newblock.get_hash();
        Ok(newblock)
    }

pub fn mine_block（&mut self，事务：Vec，链：i32）->结果{
println！（“挖掘新区块”）；
用于tx in和事务处理{
如果！自我验证交易（tx）{
返回错误（格式错误）（“错误：无效事务”）；
}
}
让标题=匹配链{
1=>“链1”，
2=>“链2”，
_=>恐慌！（“未知链索引！”）
};
设wchain=匹配链{
1=>“数据2/块”，
2=>“数据/块”，
_=>恐慌！（“未知链索引！”）
};
设wchain1=匹配链{
2=>“数据2/块”，
1=>“数据/块”，
_=>恐慌！（“未知链索引！”）
};
让db1=sled:：open（wchain）？；
设db=sled:：open（wchain1）？；
println！（“开采新的11号区块”）；
println！（“开采新区块1”）；
让lasthash=self.db.get（“LAST”）？.unwrap（）；
println！（“开采新区块2”）；
让lasthash1=db.get（“LAST”）？.unwrap（）；
println！（“开采新区块3”）；
让newblock=Block:：new_Block(
交易，
String:：from_utf8（lasthash.to_vec（））？，
String:：from_utf8（lasthash1.to_vec（））？，
字符串：：from（头），
自身获得最佳高度（链）？+1，
)?;
println！（“开采新区块4”）；
火柴链{
1 => {
self.db.insert（newblock.get_hash（），序列化（&newblock）？）？；
self.db.insert（“LAST”，newblock.get_hash（）.as_bytes（））？；
self.db.flush（）？；
}
2 => {
db1.insert（newblock.get_hash（），serialize（&newblock）？）？；
db1.insert（“LAST”，newblock.get_hash（）.as_bytes（））？；
db1.flush（）？；
}
_=>恐慌！（“未知链索引！”）
};
self.tip=newblock.get_hash（）；
Ok（新锁）
}

所有这些变量名和两个数据库之间的切换都非常复杂，因此任何人都可能会错过一些错误，我建议您通过分别更新每个数据库来仔细重构它。您还有

db

，

db1

，

self.db

，它们之间的关系还不清楚