多线程总结四：线程同步（一）

1、线程安全问题

a、银行取钱问题：取钱时银行系统判断账户余额是否大于取款金额，如果是，吐出钞票，修改余额。这个流程在多线程并发的场景下就可能会出现问题。

/**
 * @Title: Account.java 
 * @Package  
 * @author 任伟
 * @date 2014-12-8 下午5:35:27 
 * @version V1.0  
 */

/**
 * @ClassName: Account
 * @Description: 账户类
 * @author 任伟
 * @date 2014-12-8 下午5:35:27
 */
public class Account {
    private String accountNo; // 账户编号
    private double balance; // 账户余额

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public Account() {
        super();
    }

    public Account(String accountNo, double balance) {
        super();
        this.accountNo = accountNo;
        this.balance = balance;
    }

    public boolean equals(Object anObject) {
        if(this==anObject)
            return true;
        if(anObject!=null && anObject.getClass()==Account.class){
            Account target = (Account) anObject;
            return target.getAccountNo().equals(accountNo);
        }
        return false;
    }

    public int hashCode() {
        return accountNo.hashCode();
    }

}

/**
 * @Title: DrawThread.java 
 * @Package  
 * @author 任伟
 * @date 2014-12-8 下午5:41:46 
 * @version V1.0  
 */

/**
 * @ClassName: DrawThread
 * @Description: 取钱类
 * @author 任伟
 * @date 2014-12-8 下午5:41:46
 */
public class DrawThread extends Thread {
    private Account account; // 用户帐户
    private double drawAmount; // 希望取的钱数

    public DrawThread(String name, Account account, double drawAmount) {
        super(name);
        this.account = account;
        this.drawAmount = drawAmount;
    }
    
    //当多个线程修改同一共享数据时，将涉及线程安全问题
    /* (non-Javadoc)
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {
        if(account.getBalance()>=drawAmount){
            System.out.println(this.getName()+"取钱成功，吐出钞票："+drawAmount);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            account.setBalance(account.getBalance()-drawAmount);
            System.out.println("余额为："+account.getBalance());
        }else{
            System.out.println(this.getName()+"取钱失败！余额不足！");
        }
    }
    
    public static void main(String[] args) {
        //创建一个账户
        Account acct = new Account("1234567", 1000);
        //模拟两个线程对同一个账户取钱
        new DrawThread("甲", acct, 800).start();
        new DrawThread("乙", acct, 800).start();
    }

}

运行结果：

2、同步代码块

a、Java多线程引入了同步监视器来解决这个问题：线程开始执行同步代码块之前，必须先获得对同步监视器的锁定，在同步代码块执行完以后，该线程会释放对该同步监视器的锁定。通常使用可能被并发访问的共享资源充当同步监视器。

 synchronized(obj){//obj同步监视器 2 //同步代码块 3 } 

/**
 * @Title: SynchronizedBlockDrawThread.java 
 * @Package  
 * @author 任伟
 * @date 2014-12-8 下午5:59:06 
 * @version V1.0  
 */

/**
 * @ClassName: SynchronizedBlockDrawThread
 * @Description: 使用Account作为同步监视器
 * @author 任伟
 * @date 2014-12-8 下午5:59:06
 */
public class SynchronizedBlockDrawThread extends Thread {
    private Account account; // 用户帐户
    private double drawAmount; // 希望取的钱数

    public SynchronizedBlockDrawThread(String name, Account account,
            double drawAmount) {
        super(name);
        this.account = account;
        this.drawAmount = drawAmount;
    }

    // 当多个线程修改同一共享数据时，将涉及线程安全问题
    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {
        synchronized (account) {
            if (account.getBalance() >= drawAmount) {
                System.out.println(this.getName() + "取钱成功，吐出钞票：" + drawAmount);
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                account.setBalance(account.getBalance() - drawAmount);
                System.out.println("余额为：" + account.getBalance());
            } else {
                System.out.println(this.getName() + "取钱失败！余额不足！");
            }
        }
    }

    public static void main(String[] args) {
        // 创建一个账户
        Account acct = new Account("1234567", 1000);
        // 模拟两个线程对同一个账户取钱
        new SynchronizedBlockDrawThread("甲", acct, 800).start();
        new SynchronizedBlockDrawThread("乙", acct, 800).start();
    }

}

运行结果：

 

3、同步方法
a、使用synchronized关键字来修饰某一个方法，使用this作为同步监视器，也就是调用该方法的对象。
将Account变为线程安全的类：

/**
 * @Title: Account2.java 
 * @Package  
 * @author 任伟
 * @date 2014-12-8 下午6:50:34 
 * @version V1.0  
 */

/** 
 * @ClassName: Account2 
 * @Description: 线程安全Account类
 * @author 任伟
 * @date 2014-12-8 下午6:50:34  
 */
public class Account2 {
    private String accountNo; // 账户编号
    private double balance; // 账户余额
    
    public Account2() {
        super();
    }

    public Account2(String accountNo, double balance) {
        super();
        this.accountNo = accountNo;
        this.balance = balance;
    }

    public boolean equals(Object anObject) {
        if(this==anObject)
            return true;
        if(anObject!=null && anObject.getClass()==Account.class){
            Account target = (Account) anObject;
            return target.getAccountNo().equals(accountNo);
        }
        return false;
    }

    public int hashCode() {
        return accountNo.hashCode();
    }
    
    public synchronized void draw(double drawAmount){
        if (balance >= drawAmount) {
            System.out.println(Thread.currentThread().getName() + "取钱成功，吐出钞票：" + drawAmount);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            balance -= drawAmount;
            System.out.println("余额为：" + balance);
        } else {
            System.out.println(Thread.currentThread().getName() + "取钱失败！余额不足！");
        }
    }
}

/**
 * @Title: DrawThread2.java 
 * @Package  
 * @author 任伟
 * @date 2014-12-8 下午6:54:59 
 * @version V1.0  
 */

/**
 * @ClassName: DrawThread2
 * @Description: 取钱类
 * @author 任伟
 * @date 2014-12-8 下午6:54:59
 */
public class DrawThread2 extends Thread {
    private Account2 account; // 用户帐户
    private double drawAmount; // 希望取的钱数

    public DrawThread2(String name, Account2 account, double drawAmount) {
        super(name);
        this.account = account;
        this.drawAmount = drawAmount;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {
        account.draw(drawAmount);
    }

    public static void main(String[] args) {
        // 创建一个账户
        Account2 acct = new Account2("1234567", 1000);
        // 模拟两个线程对同一个账户取钱
        new DrawThread2("甲", acct, 800).start();
        new DrawThread2("乙", acct, 800).start();
    }
}

运行结果：

4、延伸
a、synchronized关键字。可以修饰方法，可以修饰代码块，但不能修饰构造器、成员变量等。

b、Domain Driven Design：在面向对象里有一种设计方法：Domain Driven Design（领域驱动设计，DDD），这种方式认为每个类都应该是完备的领域对象，例如Account代表用户帐户，应该提供用户帐户的相关方法；通过draw（）方法来执行取钱操作，而不是将setBalance()方法暴露出来任人操作，才能更好地保证Account对象的完整性和一致性。

c、线程安全类特征：通过同步方法可以非常方便的实现线程安全的类，线程安全的类具有如下特征：
.该类的对象可以被多个线程安全地访问；
.每个线程调用该类的任意方法后都能得到正确的结果；
.每个线程调用该类的任意方法后，该对象状态依然保持合理的状态；

d、可变类和不可变类(Mutable and Immutable Objects)：
可变类：当你获得这个类的一个实例引用时，你可以改变这个实例的内容。
不可变类：当你获得这个类的一个实例引用时，你不可以改变这个实例的内容。不可变类的实例一但创建，其内在成员变量的值就不能被修改。

e、如何创建一个自己的不可变类：
.所有成员都是private
.不提供对成员的改变方法，例如：setXXXX
.确保所有的方法不会被重载。手段有两种：使用final Class(强不可变类)，或者将所有类方法加上final(弱不可变类)。
.如果某一个类成员不是原始变量(primitive)或者不可变类，必须通过在成员初始化(in)或者get方法(out)时通过深度clone方法，来确保类的不可变。

f、不可变类总是线程安全的，因为对象状态不可变；可变类需要额外的方法保证其线程安全。

5、线程安全与运行效率
可变类的线程安全是以降低程序的运行效率作为代价的，为了减少线程安全所带来的负面影响，可采用以下策略：
a、不要对线程安全类的所有方法都进行同步，只对那些会改变竞争资源（共享资源）的方法同步；
b、如果可变类有两种运行环境：单线程环境和多线程环境，这应该提供该类的线程不安全版本和线程安全版本；