多线程同步：使用100个线程给一个账户金额进行每次+1操作

思路分析：

        如何创建100个线程？---使用池化技术，创建线程池。

        如何保证线程安全问题，同一时刻只有一个线程对账户进行+1操作？---使用Lock锁或者synchronized锁。

第一步：创建一个账户对象

对象中属性有账户余额，存钱方法，获取账户余额的公有方法

class  Account{
    private double balance;     // 账户余额

    /**
     * 存款
     * @param money 存入金额
     */
    
    public void deposit( double money) {
        double newBalance = balance + money;
        balance = newBalance;
    }

    /**
     * 获得账户余额
     */
    public double getBalance() {
        return balance;
    }
}

第二步：创建线程类

类中有账户对象，存入的金额，构造器，run方法中调用账户对象的加钱方法

class AddMoneyThread implements Runnable{
    private Account account;    // 存入账户
    private double money;       // 存入金额

    public AddMoneyThread(Account account, double money) {
        this .account = account;
        this .money = money;
    }

    @Override
    public void run() {

            account.deposit(money);
    }
}

第三步：创建主函数

在主函数中创建一个账户对象，创建一个100个线程的线程池，执行操作并打印最终结果，这里特别注意while循环这一块代码，添加这块代码是为了判断所有线程任务是否执行完毕，如果执行完毕则向下走，打印输出结果，没有执行完毕继续循环等待，直到所有线程任务执行完毕，如何不加这个循环判断，打印结果很可能会不准确，因为service.shtdown()后并不是所有线程都执行完毕，此时主线程继续向下走，输出账户余额是子线程没执行完的某一时刻的值。

public class AccountThread {
    public static void main(String[] args) {
        Account account = new Account();
        ExecutorService service = Executors.newFixedThreadPool(100);

        for (int i = 0; i < 100; i++) {
            //第一种使用synchronized
           service.execute( new AddMoneyThread(account, 1));
            

        }
        service.shutdown();

        while (!service.isTerminated()){}
        System.out.println(account.getBalance());
    }
}

第四步：使用synchronized锁来实现线程同步

第一种：对账户加钱方法进行加锁，重写后的账户类如下

class  Account{
    private double balance;     // 账户余额

    /**
     * 存款
     * @param money 存入金额
     */
    //锁存钱方法
    public synchronized void deposit( double money) {
        double newBalance = balance + money;
        balance = newBalance;
    }

    /**
     * 获得账户余额
     */
    public double getBalance() {
        return balance;
    }
}

第二种：对账户对象进行加锁，修改线程类代码，修改后如下

class AddMoneyThread implements Runnable{
    private Account account;    // 存入账户
    private double money;       // 存入金额

    public AddMoneyThread(Account account, double money) {
        this .account = account;
        this .money = money;
    }

    @Override
    public void run() {


        //锁整个账户对象
        synchronized (account){
            account.deposit(money);
            System.out.println(account.getBalance());
        }

    }
}

第五步：使用Lock锁来实现线程同步

原理就是给对象加一个锁属性，每次执行的时候判断是否有对象锁，有就执行，没有就等待，执行对象方法之前要手动加锁，执行完毕之后也要手动释放锁。修改账户对象，如下

class  Account2{
    private Lock reentrantLock = new ReentrantLock();
    private double balance;     // 账户余额

    /**
     * 存款
     * @param money 存入金额
     */
    public  void deposit( double money) {
        reentrantLock.lock();

        double newBalance = 0;
        try {
            newBalance = balance + money;
            balance = newBalance;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            reentrantLock.unlock();
        }

    }

    /**
     * 获得账户余额
     */
    public double getBalance() {
        return balance;
    }
}

线程类也要随之修改，因为使用了不同账户对象

class AddAccountThread2 implements Runnable{
    private Account2 account2;
    private double money;

    public AddAccountThread2(Account2 account2, double money) {
        this.account2 = account2;
        this.money = money;
    }

    @Override
    public void run() {
        account2.deposit(money);
    }
}

因为账户对象和线程类发生了变化，执行的主函数代码有需要稍微改动一下

public class AccountThread {
    public static void main(String[] args) {
        Account2 account2 = new Account2();
        ExecutorService service = Executors.newFixedThreadPool(100);

        for (int i = 0; i < 1000; i++) {
         
            //第二种使用reentrantLock
            service.execute(new AddAccountThread2(account2,1));

        }
        service.shutdown();

        while (!service.isTerminated()){}
        System.out.println(account2.getBalance());
    }
}