一文读懂Java多线程背后的故事

 public class DataLoader implements Runnable {
        private final DataService dataService;
        private final Consumer<Data> onDataLoaded;
        public DataLoader(DataService dataService, Consumer<Data> onDataLoaded) {
            this.dataService = dataService;
            this.onDataLoaded = onDataLoaded;
        }
        @Override
        public void run() {
            Data data = dataService.loadData();
            onDataLoaded.accept(data);
        }
    }
    public class PageController {
        private final DataService dataService;
        public PageController(DataService dataService) {
            this.dataService = dataService;
        }
       public void displayPage() {
            // 显示页面，提供反馈信息
            showLoadingIndicator();
            // 异步加载数据
            DataLoader dataLoader = new DataLoader(dataService, data -> {
                hideLoadingIndicator();
                updatePageWithData(data);
            });
            Thread thread = new Thread(dataLoader);
            thread.start();
        }
    }

public class FibonacciTask implements Callable<Long> {
      private final int n;
      public FibonacciTask(int n) {
          this.n = n;
      }
    @Override
    public Long call() {
        if (n <= 1) {
            return (long) n;
        } else {
            FibonacciTask f1 = new FibonacciTask(n - 1);
            FibonacciTask f2 = new FibonacciTask(n - 2);
            ForkJoinTask.invokeAll(f1, f2);
            return f1.join() + f2.join();
        }
    }
}
public class FibonacciExample {
    public static void main(String[] args) throws Exception {
        int n = 50;
        FibonacciTask task = new FibonacciTask(n);
        long result = ForkJoinPool.commonPool().invoke(task);
        System.out.println("Fibonacci number at position " + n + " is " + result);
    }
}    

public class BankAccount {
        private int balance;
        public synchronized void deposit(int amount) {
            balance += amount;
        }
        public synchronized void withdraw(int amount) {
            balance -= amount;
        }
        public synchronized int getBalance() {
            return balance;
        }
    }
    public class TransferTask implements Runnable {
        private final BankAccount sourceAccount;
        private final BankAccount targetAccount;
        private final int amount;
        public TransferTask(BankAccount sourceAccount, BankAccount targetAccount, int amount) {
            this.sourceAccount = sourceAccount;
            this.targetAccount = targetAccount;
            this.amount = amount;
        }
        @Override
        public void run() {
            sourceAccount.withdraw(amount);
            targetAccount.deposit(amount);
        }
    }
    public class BankExample {
        public static void main(String[] args) {
            BankAccount account1 = new BankAccount();
            BankAccount account2 = new BankAccount();
            account1.deposit(1000);
            TransferTask transferTask1 = new TransferTask(account1, account2, 500);
            TransferTask transferTask2 = new TransferTask(account2, account1, 300);
            Thread thread1 = new Thread(transferTask1);
            Thread thread2 = new Thread(transferTask2);
            thread1.start();
            thread2.start();
            try {
                thread1.join();
                thread2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Account 1 balance: " + account1.getBalance());
            System.out.println("Account 2 balance: " + account2.getBalance());
        }
    }