为什么只算一个文件

Question

创建一个同步多线程系统，以确定三个文本文件中所有整数或分数的总数。如果流被阻塞，则必须将其名称显示为"LOCKED"。为什么只计算一个文件（带锁的线程）？程序显示的内容：Thread-0 Locked！线程-2锁定！123.321 322099只有一个文件

import java.io.*;
    import java.util.*;
    import java.util.concurrent.locks.*;
     
    public class Dispatcher {
     
        public static void main(String[] args) throws InterruptedException {
     
            SumOfDigits sumOfDigits = new SumOfDigits();
     
            Thread thread = new Handler(new File("text.txt"), sumOfDigits);
            Thread thread2 = new Handler(new File("text2.txt"), sumOfDigits);
            Thread thread3 = new Handler(new File("text3.txt"), sumOfDigits);
            thread.start();
            thread2.start();
            thread3.start();
            thread.join();
            thread2.join();
            thread3.join();
     
            System.out.println(sumOfDigits.resultDouble + " " + sumOfDigits.resultInt);
        }
     
    }
     
     
    class SumOfDigits {
        double resultDouble;
        int resultInt;
        Lock lock = new ReentrantLock();
     
        void sum(File file) {
            try (Scanner sc = new Scanner(file)) {
                int tempInt = 0;
                double tempDouble = 0;
                while (sc.hasNext()) {
                    String num = sc.next();
                    if (num.contains(".")) {
                        tempDouble += Double.parseDouble(num);
                    } else {
                        tempInt += Integer.parseInt(num);
                    }
                }
                boolean flag = lock.tryLock();
                if (flag) {
                    try {
                        resultDouble += tempDouble;
                        resultInt += tempInt;
                    } catch (Exception e) {
                    } finally {
                        lock.unlock();
                    }
                } else {
                    System.out.println(Thread.currentThread().getName() + " Locked!");
                }
     
            } catch (Exception e) {
            }
        }
    }
     
    class Handler extends Thread {
        File file;
        SumOfDigits sumOfDigits;
     
        Handler(File file, SumOfDigits sumOfDigits) {
            this.file = file;
            this.sumOfDigits = sumOfDigits;
        }
     
        @Override
        public void run() {
            sumOfDigits.sum(file);
        }
    }

Answer 1

ReentrantLock记录当前线程锁定它的次数。每次调用unlock（）时，此计数都会减少，当计数为零时，锁就会释放。因此，要解锁锁，必须调用unlock（）的次数与调用lock（）或tryLock（）的次数相同。

在代码中，调用tryLock（），如果成功，则在try/finally块中调用lock（），然后调用unlock（）一次。

因此，第一个锁定ReentantLock的线程会将计数增加到两个，但只会将计数减少到一个，因此锁永远不会被释放。因此，没有其他线程可以获得锁。

您应该使用tryLock（）或lock（）来锁定ReentrantLock，而不是两者都使用。