多线程(100个线程同时向一个银行账户中存入1元钱)

当100个线程同时向一个银行账户中存入1元钱
在没有使用同步机制时候

/**
 * 银行账户
 * @author wb
 *
 */
public class Account {
    private double balance;     // 账户余额

    /**
     * 存款
     * @param money 存入金额
     */
    public void deposit(double money) {
        double newBalance = balance + money;
        try {
            Thread.sleep(10);   // 执行某个存钱的方法
        }
        catch(InterruptedException ex) {
            ex.printStackTrace();
        }
        balance = newBalance;
    }

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

/**
 * 存钱线程
 * @author wb
 *
 */
public 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);
    }

}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test01 {

    public static void main(String[] args) {
        /** 创建银行账户对象 */
        Account account = new Account();
        /** 创建100线程池 */
        ExecutorService service = Executors.newFixedThreadPool(100);

        for(int i = 1; i <= 100; i++) {
            /** 调用构造方法 */
            service.execute(new AddMoneyThread(account, 1));
        }

		/** 关闭线程 */
        service.shutdown();
        /** 若关闭后所有任务都已完成，则返回true */
        while(!service.isTerminated()) {}

        System.out.println("账户余额: " + account.getBalance());
    }
}

运行结果始终不是100，解决这个问题的办法就是同步，当一个线程对银行账户存钱时，需要将此账户锁定，待其操作完成后才允许其他的线程进行操作

public class Account {

    private Lock accountLock = new ReentrantLock();

    private double balance;     // 账户余额

    /**
     * 存款
     *
     * @param money 存入金额
     */
    public synchronized void deposit(double money) {

        accountLock.lock();

        try {
            double newBalance = balance + money;
            try {
                Thread.sleep(10);   // 模拟此业务需要一段处理时间
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
            balance = newBalance;
        } finally {
            accountLock.unlock();
        }

    }

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

}

public 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);
        }
    }

}

public class Test01 {

    public static void main(String[] args) {
        /** 创建银行账户对象 */
        Account account = new Account();
        /** 创建100线程池 */
        ExecutorService service = Executors.newFixedThreadPool(100);

        for (int i = 1; i <= 100; i++) {
            /** 调用构造方法 */
            service.execute(new AddMoneyThread(account, 1));
        }

        /** 关闭线程 */
        service.shutdown();

        /** 若关闭后所有任务都已完成，则返回true */
        while (!service.isTerminated()) {
        }

        System.out.println("账户余额: " + account.getBalance());
    }

}

执行结果为100。

总结：
isShutDown：当调用shutdown()或shutdownNow()方法后返回为true。
isTerminated：当调用shutdown()方法后，并且所有提交的任务完成后返回为true;
isTerminated：当调用shutdownNow()方法后，成功停止后返回为true;如果线程池任务正常完成，都为 false

ReentrantLock：重入锁; 可重入锁
new ReentrantLock(); //参数默认为false,不公平锁
new ReentrantLock(true); // 公平锁

accountLock.lock();//如果被其他资源锁定，会在此等等待释放，达到暂停的效果
accountLock.tryLock(10, TimeUnit.SECONDS);//如果发现该操作已经在执行，则尝试等待一段时间，等待超时则不执行（尝试等待执行
accountLock.lockInterruptibly();//如果发现该操作已经在执行，等待执行。这时可中断正在进行的操作立刻释放锁继续下一操作

synchronized: 可以将对象或者方法标记为同步
　synchronized有三种方式来加锁，分别是：方法锁，对象锁synchronized(this)，类锁synchronized(Demo.Class)。其中在方法锁层面可以有如下3种方式：

1. 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁
2. 静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁
3. 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。