什么是线程，线程需要怎么做

可能有些人会对线程操作了解的很模糊，只是知道像众人拾柴生火一样，但不知道是如何具体实现的，下面我举个例子来介绍一下。

例：大家到银行存钱的场景，正常大家写的程序肯定会是这样，创建一个银行类和一个存钱操作的类

package com.warrior.controller;

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

	/**
	 * 存款
	 * 
	 * @param money 存入金额
	 * @return
	 */
	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;
	}
}

存钱操作的类

package com.warrior.controller;

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

测试类

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

	        for(int i = 1; i <= 100; i++) {
	            service.execute(new AddMoneyThread(account, 1));
	        }

	        service.shutdown();

	        while(!service.isTerminated()) {}

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

这个操作是开启了100个线程，模拟100个用户进行同步存钱操作，都是存1块，银行的余额在大家执行的时候，一定不是100，有些事1.00，有些不超过10；
这就是因为没有添加线程锁的原因，相信通过这个例子，你应该明白了为什么是线程，为什么要多线程。
那么我们应该怎么处理这种同步的操作也实现我们想要的功能呢？

第一种方法：通过增加synchronized关键字，这个关键字的作用是当程序运行到存钱操作时，它会自动检查是否还有其他线程在执行这个方法，如果有线程B在执行这个方法，那么他会等待线程B结束后执行。

package com.warrior.controller;

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

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

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

	}

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

package com.warrior.controller;

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 static void main(String[] args) {
	        Account account = new Account();
	        ExecutorService service = Executors.newFixedThreadPool(100);

	        for(int i = 1; i <= 100; i++) {
	            service.execute(new AddMoneyThread(account, 1));
	        }

	        service.shutdown();

	        while(!service.isTerminated()) {}

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

当我们再运行时，结果是不是不一样了呢。下面我们介绍第二种方法：

第二种方法：通过增加线程锁，只在运行程序时做开关锁操作，这种方法可能更好理解。

package com.warrior.controller;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Account {
	private Lock accountLock = new ReentrantLock();
	private double balance;     // 账户余额

    /**
     * 存款
     * @param money 存入金额
     * @return 
     */
    public 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;
    }
}

package com.warrior.controller;

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