多线程同步:使用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());
    }
}

你可能感兴趣的:(java,开发语言)