for java 加锁 java怎么加锁

在没有同步的情况下，执行结果通常是显示账户余额在10元以下，出现这种状况的原因是，当一个线程A试图存入1元的时候，另外一个线程B也能够进入存款的方法中，线程B读取到的账户余额仍然是线程A存入1元钱之前的账户余额，因此也是在原来的余额0上面做了加1元的操作，同理线程C也会做类似的事情，所以最后100个线程执行结束时，本来期望账户余额为100元，但实际得到的通常在10元以下（很可能是1元哦）。解决这个问题的办法就是同步，当一个线程对银行账户存钱时，需要将此账户锁定，待其操作完成后才允许其他的线程进行操作，代码有如下几种调整方案：


1.在银行账户的存款（deposit）方法上同步（synchronized）关键字
2.在线程调用存款方法时对银行账户进行同步
3.通过Java 5显示的锁机制，为每个银行账户创建一个锁对象，在存款操作进行加锁和解锁的操作

下面实现的是第三种：

账号类：

package test.kang.executors;

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


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

    static String a=new String("");
    private Lock accountLock = new ReentrantLock();
    /**
     * 存款
     * @param money 存入金额
     */
   /* 第一种：使用synchronized，这里是块锁，方法锁改在方法加就好
   public void deposit(double money) {
    	synchronized(a){
    		 double newBalance = balance + money;
    	        try {
    	            Thread.sleep(10);   // 模拟此业务需要一段处理时间
    	        }
    	        catch(InterruptedException ex) {
    	            ex.printStackTrace();
    	        }
    	        balance = newBalance;
    	}
       
    }*/
    /**
     * 存款
     * @param money 存入金额
     */
    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 test.kang.executors;

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

测试类：

package test.kang;

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

import test.kang.executors.Account;
import test.kang.executors.AddMoneyThread;

public class Test_Executors {
	public static void main(String[] args) {
		Account account = new Account();
		/*Executors类，提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口
		 * 1.public static ExecutorService newFixedThreadPool(int nThreads)
			创建固定数目线程的线程池。
		   2.public static ExecutorService newCachedThreadPool()
			创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
		   3.public static ExecutorService newSingleThreadExecutor()
			创建一个单线程化的Executor。
		   4.public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
			创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

		 * 
		 * */
		
		/*ExecutorService扩展了Executor并添加了一些生命周期管理的方法
		 * 一个Executor的生命周期有三种状态，运行 ，关闭 ，终止 。
		 * 1.Executor创建时处于运行状态。
		 * 2.当调用ExecutorService.shutdown()后，处于关闭状态，isShutdown()方法返回true。
		 * 这时，不应该再想Executor中添加任务.
		 * 3.所有已添加的任务执行完毕后，Executor处于终止状态，isTerminated()返回true。
		 * 
		 * 注意：如果Executor处于关闭状态，往Executor提交任务会抛出unchecked exception RejectedExecutionException。
		*/
//		Executor service = Executors.newFixedThreadPool(100);
		ExecutorService service = Executors.newFixedThreadPool(100);

		for(int i = 1; i <= 100; i++) {//存一百快，没有实现锁机制时，少于100.
			service.execute(new AddMoneyThread(account, 1));
		}

		service.shutdown();

		while(!service.isTerminated()) {}

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