分布式系统核心算法详解：PoW算法原理与Java实现

1
2
3
4
5

工作量证明原理：
1. 提出一个计算难题（通常是寻找特定哈希值）
2. 矿工竞争解决这个难题
3. 最先解决难题的矿工获得记账权
4. 其他节点验证解决方案并接受新区块

1

Hash(Block Header + nonce) < Target

1
2
3
4
5

A[当前区块] → B[计算平均出块时间]
B → C{时间是否符合预期?}
C →|太快| D[增加难度]
C →|太慢| E[降低难度]
C →|合适| F[保持难度]

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240

import java.security.MessageDigest;
import java.time.Instant;
import java.util.*;

/**
 * 区块头结构
 */
public class BlockHeader {
    private final String previousHash;  // 前一个区块的哈希
    private final String merkleRoot;    // Merkle树根
    private final long timestamp;       // 时间戳
    private final int difficulty;       // 难度值
    private long nonce;                 // 随机数

    public BlockHeader(String previousHash, String merkleRoot, int difficulty) {
        this.previousHash = previousHash;
        this.merkleRoot = merkleRoot;
        this.timestamp = Instant.now().getEpochSecond();
        this.difficulty = difficulty;
        this.nonce = 0;
    }

    /**
     * 计算区块头哈希
     */
    public String calculateHash() {
        try {
            String data = previousHash + merkleRoot + timestamp + difficulty + nonce;
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(data.getBytes("UTF-8"));

            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) {
                    hexString.append('0');
                }
                hexString.append(hex);
            }
            return hexString.toString();

        } catch (Exception e) {
            throw new RuntimeException("计算哈希失败", e);
        }
    }

    /**
     * 检查是否满足难度要求
     */
    public boolean isValidHash(String hash) {
        String target = "0".repeat(difficulty);
        return hash.startsWith(target);
    }

    // Getters and Setters
    public String getPreviousHash() { return previousHash; }
    public String getMerkleRoot() { return merkleRoot; }
    public long getTimestamp() { return timestamp; }
    public int getDifficulty() { return difficulty; }
    public long getNonce() { return nonce; }
    public void setNonce(long nonce) { this.nonce = nonce; }
}

/**
 * 交易结构
 */
public class Transaction {
    private final String id;            // 交易ID
    private final String from;          // 发送方
    private final String to;            // 接收方
    private final double amount;        // 交易金额
    private final long timestamp;       // 时间戳
    private String signature;           // 数字签名

    public Transaction(String from, String to, double amount) {
        this.from = from;
        this.to = to;
        this.amount = amount;
        this.timestamp = Instant.now().getEpochSecond();
        this.id = calculateTransactionId();
    }

    /**
     * 计算交易ID
     */
    private String calculateTransactionId() {
        try {
            String data = from + to + amount + timestamp;
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(data.getBytes("UTF-8"));

            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) {
                    hexString.append('0');
                }
                hexString.append(hex);
            }
            return hexString.toString();

        } catch (Exception e) {
            throw new RuntimeException("计算交易ID失败", e);
        }
    }

    /**
     * 验证交易
     */
    public boolean isValid() {
        // 简化的验证逻辑
        return from != null && to != null && amount > 0 && !from.equals(to);
    }

    // Getters
    public String getId() { return id; }
    public String getFrom() { return from; }
    public String getTo() { return to; }
    public double getAmount() { return amount; }
    public long getTimestamp() { return timestamp; }
    public String getSignature() { return signature; }
    public void setSignature(String signature) { this.signature = signature; }

    @Override
    public String toString() {
        return String.format("Transaction{id='%s', from='%s', to='%s', amount=%.2f}",
                id, from, to, amount);
    }
}

/**
 * 区块结构
 */
public class Block {
    private final BlockHeader header;
    private final List<Transaction> transactions;
    private String hash;

    public Block(String previousHash, List<Transaction> transactions, int difficulty) {
        this.transactions = new ArrayList<>(transactions);
        String merkleRoot = calculateMerkleRoot(transactions);
        this.header = new BlockHeader(previousHash, merkleRoot, difficulty);
        this.hash = null;
    }

    /**
     * 计算Merkle树根
     */
    private String calculateMerkleRoot(List<Transaction> transactions) {
        if (transactions.isEmpty()) {
            return "0";
        }

        List<String> hashes = new ArrayList<>();
        for (Transaction tx : transactions) {
            hashes.add(tx.getId());
        }

        while (hashes.size() > 1) {
            List<String> newHashes = new ArrayList<>();
            for (int i = 0; i < hashes.size(); i += 2) {
                String left = hashes.get(i);
                String right = (i + 1 < hashes.size()) ? hashes.get(i + 1) : left;
                newHashes.add(hashPair(left, right));
            }
            hashes = newHashes;
        }

        return hashes.get(0);
    }

    /**
     * 计算两个哈希的组合哈希
     */
    private String hashPair(String left, String right) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest((left + right).getBytes("UTF-8"));

            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) {
                    hexString.append('0');
                }
                hexString.append(hex);
            }
            return hexString.toString();

        } catch (Exception e) {
            throw new RuntimeException("计算哈希对失败", e);
        }
    }

    /**
     * 验证区块
     */
    public boolean isValid() {
        // 验证交易
        for (Transaction tx : transactions) {
            if (!tx.isValid()) {
                return false;
            }
        }

        // 验证Merkle根
        String calculatedMerkleRoot = calculateMerkleRoot(transactions);
        if (!calculatedMerkleRoot.equals(header.getMerkleRoot())) {
            return false;
        }

        // 验证哈希
        if (hash != null) {
            String calculatedHash = header.calculateHash();
            if (!calculatedHash.equals(hash)) {
                return false;
            }

            // 验证是否满足难度要求
            if (!header.isValidHash(hash)) {
                return false;
            }
        }

        return true;
    }

    // Getters
    public BlockHeader getHeader() { return header; }
    public List<Transaction> getTransactions() { return new ArrayList<>(transactions); }
    public String getHash() { return hash; }
    public void setHash(String hash) { this.hash = hash; }

    @Override
    public String toString() {
        return String.format("Block{hash='%s', previousHash='%s', transactions=%d, difficulty=%d, nonce=%d}",
                hash, header.getPreviousHash(), transactions.size(),
                header.getDifficulty(), header.getNonce());
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

/**
 * 挖矿奖励管理
 */
public class MiningReward {
    private static final double INITIAL_REWARD = 50.0;  // 初始奖励
    private static final int HALVING_INTERVAL = 210000;  // 减半间隔（区块数）
    private static final double MIN_REWARD = 0.00000001; // 最小奖励

    /**
     * 计算区块奖励
     */
    public static double calculateBlockReward(int blockHeight) {
        int halvings = blockHeight / HALVING_INTERVAL;
        double reward = INITIAL_REWARD;

        for (int i = 0; i < halvings; i++) {
            reward /= 2.0;
            if (reward < MIN_REWARD) {
                reward = MIN_REWARD;
                break;
            }
        }

        return reward;
    }

    /**
     * 计算交易费用
     */
    public static double calculateTransactionFees(List<Transaction> transactions) {
        // 简化实现：固定费用
        return transactions.size() * 0.001;
    }

    /**
     * 创建挖矿奖励交易（coinbase交易）
     */
    public static Transaction createCoinbaseTransaction(String minerAddress, int blockHeight,
                                                      List<Transaction> transactions) {
        double blockReward = calculateBlockReward(blockHeight);
        double transactionFees = calculateTransactionFees(transactions);
        double totalReward = blockReward + transactionFees;

        Transaction coinbase = new Transaction("SYSTEM", minerAddress, totalReward);
        return coinbase;
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;

/**
 * PoW挖矿器
 */
public class PoWMiner {
    private final String minerAddress;
    private final AtomicBoolean mining = new AtomicBoolean(false);
    private final AtomicLong hashRate = new AtomicLong(0);

    public PoWMiner(String minerAddress) {
        this.minerAddress = minerAddress;
    }

    /**
     * 挖矿方法
     */
    public MiningResult mine(Block block) {
        if (!mining.compareAndSet(false, true)) {
            throw new IllegalStateException("挖矿器已在运行");
        }

        try {
            System.out.println("开始挖矿区块，难度: " + block.getHeader().getDifficulty());
            long startTime = System.currentTimeMillis();
            long hashCount = 0;

            BlockHeader header = block.getHeader();
            String target = "0".repeat(header.getDifficulty());

            while (mining.get()) {
                header.setNonce(header.getNonce() + 1);
                String hash = header.calculateHash();
                hashCount++;

                // 每10000次哈希计算更新一次哈希率
                if (hashCount % 10000 == 0) {
                    long elapsed = System.currentTimeMillis() - startTime;
                    if (elapsed > 0) {
                        hashRate.set((hashCount * 1000) / elapsed);
                    }
                }

                if (hash.startsWith(target)) {
                    long endTime = System.currentTimeMillis();
                    block.setHash(hash);

                    MiningResult result = new MiningResult(
                        true,
                        block,
                        header.getNonce(),
                        hash,
                        hashCount,
                        endTime - startTime,
                        minerAddress
                    );

                    System.out.println("挖矿成功! Nonce: " + header.getNonce() +
                                      ", Hash: " + hash +
                                      ", 耗时: " + (endTime - startTime) + "ms" +
                                      ", 哈希次数: " + hashCount);

                    return result;
                }
            }

            // 挖矿被中断
            return new MiningResult(false, null, 0, null, hashCount,
                                  System.currentTimeMillis() - startTime, minerAddress);

        } finally {
            mining.set(false);
        }
    }

    /**
     * 停止挖矿
     */
    public void stopMining() {
        mining.set(false);
    }

    /**
     * 获取当前哈希率
     */
    public long getHashRate() {
        return hashRate.get();
    }

    /**
     * 检查是否正在挖矿
     */
    public boolean isMining() {
        return mining.get();
    }

    public String getMinerAddress() {
        return minerAddress;
    }
}

/**
 * 挖矿结果
 */
public class MiningResult {
    private final boolean success;
    private final Block block;
    private final long nonce;
    private final String hash;
    private final long hashCount;
    private final long miningTime;
    private final String minerAddress;

    public MiningResult(boolean success, Block block, long nonce, String hash,
                       long hashCount, long miningTime, String minerAddress) {
        this.success = success;
        this.block = block;
        this.nonce = nonce;
        this.hash = hash;
        this.hashCount = hashCount;
        this.miningTime = miningTime;
        this.minerAddress = minerAddress;
    }

    // Getters
    public boolean isSuccess() { return success; }
    public Block getBlock() { return block; }
    public long getNonce() { return nonce; }
    public String getHash() { return hash; }
    public long getHashCount() { return hashCount; }
    public long getMiningTime() { return miningTime; }
    public String getMinerAddress() { return minerAddress; }

    @Override
    public String toString() {
        return String.format("MiningResult{success=%s, nonce=%d, hashCount=%d, time=%dms, miner='%s'}",
                success, nonce, hashCount, miningTime, minerAddress);
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicReference;

/**
 * 多线程PoW挖矿器
 */
public class MultiThreadPoWMiner {
    private final String minerAddress;
    private final int threadCount;
    private final ExecutorService executor;
    private final AtomicBoolean mining = new AtomicBoolean(false);
    private final AtomicReference<MiningResult> result = new AtomicReference<>();

    public MultiThreadPoWMiner(String minerAddress, int threadCount) {
        this.minerAddress = minerAddress;
        this.threadCount = threadCount;
        this.executor = Executors.newFixedThreadPool(threadCount);
    }

    /**
     * 多线程挖矿
     */
    public MiningResult mine(Block block) {
        if (!mining.compareAndSet(false, true)) {
            throw new IllegalStateException("挖矿器已在运行");
        }

        try {
            System.out.println("开始多线程挖矿，线程数: " + threadCount +
                              ", 难度: " + block.getHeader().getDifficulty());

            CountDownLatch latch = new CountDownLatch(1);
            long startTime = System.currentTimeMillis();

            // 启动多个挖矿线程
            for (int i = 0; i < threadCount; i++) {
                final int threadId = i;
                executor.submit(() -> mineInThread(block, threadId, startTime, latch));
            }

            try {
                // 等待任一线程找到解
                latch.await();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }

            return result.get();

        } finally {
            mining.set(false);
        }
    }

    /**
     * 线程内挖矿逻辑
     */
    private void mineInThread(Block block, int threadId, long startTime, CountDownLatch latch) {
        BlockHeader header = block.getHeader();
        String target = "0".repeat(header.getDifficulty());
        long nonce = threadId; // 每个线程从不同的nonce开始
        long hashCount = 0;

        while (mining.get()) {
            nonce += threadCount; // 每个线程递增threadCount，避免重复计算
            header.setNonce(nonce);
            String hash = header.calculateHash();
            hashCount++;

            if (hash.startsWith(target)) {
                // 找到解
                long endTime = System.currentTimeMillis();
                block.setHash(hash);

                MiningResult minerResult = new MiningResult(
                    true,
                    block,
                    nonce,
                    hash,
                    hashCount,
                    endTime - startTime,
                    minerAddress + "-thread-" + threadId
                );

                if (result.compareAndSet(null, minerResult)) {
                    System.out.println("线程 " + threadId + " 挖矿成功! " +
                                      "Nonce: " + nonce +
                                      ", Hash: " + hash +
                                      ", 哈希次数: " + hashCount);
                    latch.countDown();
                }
                return;
            }

            // 每1000次检查一次是否应该停止
            if (hashCount % 1000 == 0 && !mining.get()) {
                break;
            }
        }
    }

    /**
     * 停止挖矿
     */
    public void stopMining() {
        mining.set(false);
    }

    /**
     * 关闭挖矿器
     */
    public void shutdown() {
        stopMining();
        executor.shutdown();
        try {
            if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }

    public boolean isMining() {
        return mining.get();
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 挖矿池
 */
public class MiningPool {
    private final String poolAddress;
    private final ConcurrentHashMap<String, PoolMiner> miners = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
    private final AtomicInteger totalHashRate = new AtomicInteger(0);

    public MiningPool(String poolAddress) {
        this.poolAddress = poolAddress;

        // 每5秒更新一次统计信息
        scheduler.scheduleAtFixedRate(this::updateStatistics, 5, 5, TimeUnit.SECONDS);
    }

    /**
     * 矿工加入矿池
     */
    public void joinPool(String minerAddress, int hashPower) {
        PoolMiner poolMiner = new PoolMiner(minerAddress, hashPower);
        miners.put(minerAddress, poolMiner);
        totalHashRate.addAndGet(hashPower);

        System.out.println("矿工 " + minerAddress + " 加入矿池，算力: " + hashPower);
    }

    /**
     * 矿工离开矿池
     */
    public void leavePool(String minerAddress) {
        PoolMiner poolMiner = miners.remove(minerAddress);
        if (poolMiner != null) {
            totalHashRate.addAndGet(-poolMiner.getHashPower());
            System.out.println("矿工 " + minerAddress + " 离开矿池");
        }
    }

    /**
     * 协作挖矿
     */
    public MiningResult collaborativeMining(Block block) {
        if (miners.isEmpty()) {
            throw new IllegalStateException("矿池中没有矿工");
        }

        System.out.println("矿池开始协作挖矿，参与矿工: " + miners.size() +
                          ", 总算力: " + totalHashRate.get());

        long startTime = System.currentTimeMillis();
        AtomicBoolean found = new AtomicBoolean(false);
        CompletableFuture<MiningResult> resultFuture = new CompletableFuture<>();

        // 并行挖矿
        miners.values().parallelStream().forEach(poolMiner -> {
            if (!found.get()) {
                MiningResult result = poolMiner.mine(block, found);
                if (result.isSuccess() && !resultFuture.isDone()) {
                    resultFuture.complete(result);
                }
            }
        });

        try {
            MiningResult result = resultFuture.get(60, TimeUnit.SECONDS);
            long endTime = System.currentTimeMillis();

            // 分配奖励
            distributeRewards(result, endTime - startTime);

            return result;

        } catch (Exception e) {
            found.set(true);
            throw new RuntimeException("协作挖矿失败", e);
        }
    }

    /**
     * 分配挖矿奖励
     */
    private void distributeRewards(MiningResult result, long miningTime) {
        if (!result.isSuccess()) {
            return;
        }

        // 计算总奖励（简化实现）
        double totalReward = 50.0; // 假设固定奖励
        double poolFee = totalReward * 0.02; // 2%矿池费用
        double minerReward = totalReward - poolFee;

        System.out.println("\n=== 奖励分配 ===");
        System.out.println("总奖励: " + totalReward);
        System.out.println("矿池费用: " + poolFee);
        System.out.println("矿工奖励: " + minerReward);

        // 按算力比例分配
        for (PoolMiner poolMiner : miners.values()) {
            double share = (double) poolMiner.getHashPower() / totalHashRate.get();
            double reward = minerReward * share;
            poolMiner.addReward(reward);

            System.out.println("矿工 " + poolMiner.getAddress() +
                              " 算力占比: " + String.format("%.2f%%", share * 100) +
                              " 奖励: " + String.format("%.6f", reward));
        }
        System.out.println("================\n");
    }

    /**
     * 更新统计信息
     */
    private void updateStatistics() {
        if (!miners.isEmpty()) {
            System.out.println("矿池状态 - 矿工数: " + miners.size() +
                              ", 总算力: " + totalHashRate.get());
        }
    }

    /**
     * 获取矿池统计信息
     */
    public PoolStatistics getStatistics() {
        return new PoolStatistics(
            poolAddress,
            miners.size(),
            totalHashRate.get(),
            miners.values().stream().mapToDouble(PoolMiner::getTotalReward).sum()
        );
    }

    /**
     * 关闭矿池
     */
    public void shutdown() {
        scheduler.shutdown();
    }
}

/**
 * 矿池中的矿工
 */
class PoolMiner {
    private final String address;
    private final int hashPower;
    private double totalReward = 0.0;

    public PoolMiner(String address, int hashPower) {
        this.address = address;
        this.hashPower = hashPower;
    }

    /**
     * 挖矿（模拟）
     */
    public MiningResult mine(Block block, AtomicBoolean globalFound) {
        BlockHeader header = block.getHeader();
        String target = "0".repeat(header.getDifficulty());
        long nonce = new Random().nextInt(1000000); // 随机起始点
        long hashCount = 0;
        long startTime = System.currentTimeMillis();

        while (!globalFound.get()) {
            nonce++;
            header.setNonce(nonce);
            String hash = header.calculateHash();
            hashCount++;

            if (hash.startsWith(target)) {
                globalFound.set(true);
                block.setHash(hash);

                return new MiningResult(
                    true,
                    block,
                    nonce,
                    hash,
                    hashCount,
                    System.currentTimeMillis() - startTime,
                    address
                );
            }

            // 模拟算力差异（算力越高，计算越快）
            if (hashCount % (1000 / hashPower) == 0) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }

        return new MiningResult(false, null, 0, null, hashCount,
                              System.currentTimeMillis() - startTime, address);
    }

    /**
     * 添加奖励
     */
    public void addReward(double reward) {
        totalReward += reward;
    }

    // Getters
    public String getAddress() { return address; }
    public int getHashPower() { return hashPower; }
    public double getTotalReward() { return totalReward; }
}

/**
 * 矿池统计信息
 */
class PoolStatistics {
    private final String poolAddress;
    private final int minerCount;
    private final int totalHashPower;
    private final double totalRewards;

    public PoolStatistics(String poolAddress, int minerCount, int totalHashPower, double totalRewards) {
        this.poolAddress = poolAddress;
        this.minerCount = minerCount;
        this.totalHashPower = totalHashPower;
        this.totalRewards = totalRewards;
    }

    // Getters
    public String getPoolAddress() { return poolAddress; }
    public int getMinerCount() { return minerCount; }
    public int getTotalHashPower() { return totalHashPower; }
    public double getTotalRewards() { return totalRewards; }

    @Override
    public String toString() {
        return String.format("PoolStatistics{pool='%s', miners=%d, hashPower=%d, rewards=%.6f}",
                poolAddress, minerCount, totalHashPower, totalRewards);
    }
}