线程3：线程同步

为何要使用同步？

java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了该变量的唯一性和准确性。

安全问题—银行取钱问题

public class SynDemo {

    //1.账户类
    //这里关于内部类，用static修饰，可以直接new
    //否则，要先获得外部类的实例才能new（类似：new Outter().new Inner()）
    public static class Account{   
        private int balance;        //账户本来有多少钱，在构造器中写出
        public Account(){}
        public Account(int balance){
            this.balance=balance;
        }
        public int getBalance() {
            return balance;
        }
        public void setBalance(int balance) {
            this.balance = balance;
        }


    //2.取钱类（线程类）
    static class DrawThread extends Thread {
        //取钱时需要账户和取多少
        private Account account;
        private int drawmoney;
        public DrawThread(){}
        public DrawThread(Account account,int drawmoney){
            this.account=account;
            this.drawmoney=drawmoney;
        }
        public Account getAcount() {
            return account;
        }
        public void setAcount(Account account) {
            this.account = account;
        }
        public int getDrawmoney() {
            return drawmoney;
        }
        public void setDrawmoney(int drawmoney) {
            this.drawmoney = drawmoney;
        }
        //run方法
        /*
        public void run(){
            if(account.getBalance()>=drawmoney){//余额足
                System.out.println("取钱成功，吐出钞票："+ drawmoney);  //先出钞票
                account.setBalance(account.getBalance()-drawmoney);//然后才在余额减
                System.out.println("余额："+account.getBalance());
            }else{
                System.out.println("取钱失败，余额不足！");
            }
        }
        */
        public void run(){
            if(account.getBalance()>=drawmoney){//余额足
                System.out.println("取钱成功，吐出钞票："+ drawmoney);   
                try {
                    Thread.sleep(1);           //在出钱和减钱之间sleep，会让线程2进来
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                account.setBalance(account.getBalance()-drawmoney);
                System.out.println("余额："+account.getBalance());
            }else{
                System.out.println("取钱失败，余额不足！");
            }
        }
    }
    //3.main测试
    public static void main(String[] args) {
        //简历两个取钱线程
        Account ac =new Account(1000);   //
        new DrawThread(ac,800).start();;
        new DrawThread(ac,800).start();;
    }
}

注释前的run出错的可能性小，run中加sleep后会出错。

未加同步时，余额为负，出错。以下介绍三种不同方法。

三种同步方法

线程安全方法1：（同步代码块）

/*
 *   1.同步代码块：synchronized(obj){
 *               }
 *     obj为监视器，允许为任何对象，但建议以可能并发访问的资源做监视器
 * */

public void run(){
    synchronized(account){
        if(account.getBalance()>=drawmoney){//余额足
            System.out.println("取钱成功，吐出钞票："+ drawmoney);   
            try {
              Thread.sleep(1); //在出钱和减钱之间sleep，会让线程2进来。但有同步
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            account.setBalance(account.getBalance()-drawmoney);
            System.out.println("余额："+account.getBalance());
        }else{
            System.out.println("取钱失败，余额不足！");
        }               
    }
}

说明：同步监视器对account锁定，其他线程无法获得锁。符合“加锁—修改—释放锁”的逻辑

---

方法2：用同步方法实现

（synchronized只可以修饰方法或代码块，不能修饰构造器、成员变量）

修饰普通方法，run中调用即可

在Account类中写draw方法。修饰方法或变量均可。

public synchronized void draw(int money) {                                          
      account -= money;
}

/**
  * 用同步代码块实现
  * 
  */
public void draw1(int money) {                                                       
     synchronized (this) {
         account -= money;
     }
}

---

方法3：同步锁（Lock）

java.util.concurrent.locks.ReentrantLock

同样对普通方法

public void m(){
    lock.lock();
    try{

    }finally{
        lock.unlock();
    }
}

public  class Account{   //这里关于内部类，用static修饰，可以直接new
        private int balance;            //账户本来有多少钱，在构造器中写出
        public Account(){}
        public Account(int balance){
            this.balance=balance;
        }       

        //在账户中写draw()方法
        //定义锁对象
        private final ReentrantLock lock = new ReentrantLock(); 

        public void draw(int drawmony) {
            //1.step1.加锁
            lock.lock();
            try{
                if(balance >= drawmony){//余额足
                    System.out.println("取钱成功，吐出钞票："+ drawmony);   
                    try {
                        Thread.sleep(1);           
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    balance-=drawmony;
                    System.out.println("余额："+balance);
                }else{
                    System.out.println("取钱失败，余额不足！");
                }       
            }finally{
                lock.unlock();
            }           
        }       
    }

线程类中调用

public void run(){
    //java.util.concurrent.locks.ReentrantLock
    account.draw(drawmoney);
}