Java多线程之线程同步

线程同步

线程安全问题

多线程情况下，当多个线程访问同一个数据时，很容易出现线程安全问题。

经典的问题——银行取钱问题。几个人同时取一个帐号里的钱，就可能出现问题。下面模拟一下。

//账户类
public class Account {
    private String accountNo;
    private double balance;


    public Account() {
    }

    public Account(String accountNo, double balance) {
        super();
        this.accountNo = accountNo;
        this.balance = 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;
    }


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


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


//模拟取钱线程
public class DrawThread extends Thread {

    private Account account;

    private double withDraw;

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

    @Override
    public void run() {
        //账户余额大于取钱数目
        if(account.getBalance() >= withDraw){
            System.err.println(getName() + "取钱成功！吐出：" +withDraw+" 文");
            //让线程切换
            try {
                Thread.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            }

            //减去取出的钱
            account.setBalance(account.getBalance() - withDraw);

            System.out.println("\t 余额为： " + account.getBalance());

        } else {
            System.out.println(getName() + "你的余额不足！");
        }
    }
}

//测试
public class DrawTest {

    public static void main(String[] args) {
        Account account = new Account("12345678",10000);

        new DrawThread("A", account, 8000).start();
        new DrawThread("B", account, 8000).start();
    }
}

结果：

原因：
- run()线程执行体不具有同步安全性
- 程序中有两个并发线程在修改Account对象

同步监视器

为解决上述问题，Java多线程引入同步监视器。其目的：

阻止两个线程对同一个共享资源并发访问

通常，推荐使用可能被并发访问的共享资源充当同步监视器。

流程：

加锁->修改->释放锁

同步代码块

使用同步监视器的通用方法就是同步代码块。其含义是：线程开始执行同步代码块前，必须先获得对同步监视器的锁定。因此，修改线程类，使用同步代码块给Account对象上锁。

public class DrawThread extends Thread {
...
  @Override
    public void run() {

        synchronized (account) {
            // 账户余额大于取钱数目
            if (account.getBalance() >= withDraw) {
                System.err.println(getName() + "取钱成功！吐出：" + withDraw + " 文");

                try {
                    Thread.sleep(1);
                } catch (Exception e) {
                    e.printStackTrace();
                }

                // 减去取出的钱
                account.setBalance(account.getBalance() - withDraw);

                System.out.println("\t 余额为： " + account.getBalance());

            } else {
                System.out.println(getName() + "你的余额不足！");
            }
        }
    }
...

同步方法

与同步代码块对应，还有同步方法。使用sychronized关键字修饰方法，无须显示指定同步监视器，同步方法的同步监视器就是this，就是调用该方法的对象。

那么，可以修改Account类，提供一个线程安全的draw方法

...
public synchronized void draw(double withDraw){
        // 账户余额大于取钱数目
        if (balance >= withDraw) {
            System.err.println(Thread.currentThread().getName() + "取钱成功！吐出：" + withDraw + " 文");

            try {
                Thread.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            }

            // 减去取出的钱
            balance = balance - withDraw;

            System.out.println("\t 余额为： " + balance);

        } else {
            System.out.println(Thread.currentThread().getName() + "你的余额不足！");
        }
    }
...

同步锁Lock

JDK 1.5开始，Java提供了更强大的线程同步机制
- 显式定义同步锁对象来实现同步
- 同步锁由Lock对象充当

与synchronized方法，synchronized代码块相比的优势：
- 更广泛的锁定操作
- 实现更灵活的的结构
- 可以具有差别很大的属性
- 支持多个相关的Condition对象

Lock是控制多个线程对共享资源访问的工具。锁提供了独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源前，须先获得Lock对象

JDK 1.5 提供了Lock,ReadWriteLock两个根接口，ReentrantLock可重入锁是Lock的实现类，ReentrantReadWriteLock是ReadWriteLock的实现类。

JDK 1.8 提供StampedLock类，大多数情况下，可替代传统的ReentrantReadWriteLock.

ReentrantReadWriteLock为读写操作提供3种锁模式：
- Writing
- ReadingOptimistic
- Reading

下面以ReentrantReadWriteLock为例，修改Account类

public class Account {

    private final ReentrantLock lock = new ReentrantLock();
    ...

    public void draw(double withDraw){

        // 加锁
        lock.lock();
        try {
            // 账户余额大于取钱数目
            if (balance >= withDraw) {
                System.err.println(Thread.currentThread().getName() + "取钱成功！吐出：" + withDraw + " 文");

                try {
                    Thread.sleep(1);
                } catch (Exception e) {
                    e.printStackTrace();
                }

                // 减去取出的钱
                balance = balance - withDraw;

                System.out.println("\t 余额为： " + balance);

            } else {
                System.out.println(Thread.currentThread().getName() + "你的余额不足！");
            }
        } finally {
            // 解锁
            lock.unlock();
        }
    }