关于线程同步

4.1 问题的提出 

• 应用场景：
  • 多个用户同时操作一个银行账户。每次取款400元，取款前先检查余额是否足够。如果不够，放弃取款
• 分析
  • 使用多线程解决
  • 开发一个取款线程类，每个用户对应一个线程对象
  • 因为多个线程共享同一个银行账户，使用Runnable方式解决
• 思路
  • 创建银行账户类Account
  • 创建取款线程AccountRunnable
  • 创建测试类TestAccount，让两个用户同时取款

 

【示例9】引入线程同步

/**
 * 银行账户
 */
public class Account {
    private int balance = 600;
    //取款
    public void withDraw(int money){
        this.balance = this.balance - money;
    }
    //查看余额
    public int getBalance(){
        return balance;
    }
}

public class AccountRunnable implements  Runnable {
    private Account account = new Account();
    @Override
    public void run() {
        //判断余额是否足够，够，取之；不够，不取之；
        if(account.getBalance()>=400){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //取之
            account.withDraw(400);
            //输出信息
            System.out.println(Thread.currentThread().getName()+
                    "取款成功，现在的余额是"+account.getBalance());
        }else{
     System.out.println("余额不足，"+Thread.currentThread().getName()
                  +"取款失败，现在的余额是"   +account.getBalance());
        }
    }
}

public class Test {
    public static void main(String[] args) {
        //创建两个线程
        Runnable runnable = new AccountRunnable();
        Thread zhangsanThread = new Thread(runnable);
       Thread zhangsanWifeThread =new Thread(runnable,"张三妻子");
        zhangsanThread.setName("张三");
        //启动两个线程
        zhangsanThread.start();
        zhangsanWifeThread.start();
    }
}

 

分析：使用Thread.sleep()的目的在于模拟线程切换，在一个线程判断完余额后，不是立刻取款，而是让出CPU，这样另外一个线程获取CPU，并且进行余额的判断。线程安全问题就这么产生了。如果保证安全，必须判断余额和取款的语句必须被一个线程执行完才能让另外一个线程执行。

 

• 当多个线程访问同一个数据时，容易出现线程安全问题。需要让线程同步，保证数据安全
• 线程同步
  • 当两个或两个以上线程访问同一资源时，需要某种方式来确保资源在某一时刻只被一个线程使用
• 线程同步的实现方案
  • 同步代码块
    • synchronized (obj){    }  
  • 同步方法
    • private synchronized void makeWithdrawal(int amt) {}
  • Lock锁

 

4.2 同步代码块

 

【示例10】使用同步代码块实现线程同步

public class AccountRunnable implements  Runnable {
    private Account account = new Account();
    @Override
    public void run() {
        //此处省略300句

        synchronized (account){ //锁
            //判断余额是否足够，够，取之；不够，不取之；
            if(account.getBalance()>=400){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //取之
                account.withDraw(400);
                //输出信息
                System.out.println(Thread.currentThread().getName()
                    +"取款成功，现在的余额是"+account.getBalance());
            }else{
     System.out.println("余额不足，"+Thread.currentThread().getName()
                    +"取款失败，现在的余额是"+account.getBalance());
            }
        }
        //此处省略200句
    }
}

总结1：认识同步监视器（锁子）

·    synchronized(同步监视器){ }

1) 必须是引用数据类型，不能是基本数据类型

2) 在同步代码块中可以改变同步监视器对象的值，不能改变其引用

3) 尽量不要String和包装类Integer做同步监视器.如果使用了，只要保证代码块中不对其进行任何操作也没有关系

4) 一般使用共享资源做同步监视器即可

5) 也可以创建一个专门的同步监视器，没有任何业务含义

6) 建议使用final修饰同步监视器

总结2：同步代码块的执行过程

1) 第一个线程来到同步代码块，发现同步监视器open状态，需要close,然后执行其中的代码

2) 第一个线程执行过程中，发生了线程切换（阻塞 就绪），第一个线程失去了cpu，但是没有开锁open

3) 第二个线程获取了cpu，来到了同步代码块，发现同步监视器close状态，无法执行其中的代码，第二个线程也进入阻塞状态

4) 第一个线程再次获取CPU,接着执行后续的代码；同步代码块执行完毕，释放锁open

5) 第二个线程也再次获取cpu，来到了同步代码块，发现同步监视器open状态，重复第一个线程的处理过程（加锁）

强调：同步代码块中能发生线程切换吗？能！！！ 但是后续的被执行的线程也无法执行同步代码块（锁仍旧close）

·   

总结3：线程同步 优点和缺点

·    优点：安全

·    缺点：效率低下  可能出现死锁

·   

总结4：其他

1) 多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法访问其中的任何一个代码块

2) 多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块， 但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块

4.3  同步方法

【示例11】使用同步方法实现线程同步

public class AccountRunnable implements  Runnable {
    private Account account = new Account();
    @Override
    public  void run() {
        //此处省略300句
        //判断余额是否足够，够，取之；不够，不取之；
       withDraw();
        //此处省略200句
    }

    public synchronized void withDraw(){ //同步监视器都是this
        if(account.getBalance()>=400){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //取之
            account.withDraw(400);
            //输出信息
            System.out.println(Thread.currentThread().getName()+
               "取款成功，现在的余额是"+account.getBalance());
        }else{
     System.out.println("余额不足，"+Thread.currentThread().getName()
             +"取款失败，现在的余额是"   +account.getBalance());
        }
    }
    public  synchronized  void method2(){ //this
    }
    public  synchronized  void method3(){ //this
    }
  }

总结：关于同步方法 

1) 不要讲run()定义为同步方法 

2) 同步方法的同步监视器是this

3) 同步代码块的效率要高于同步方法

u 同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块

u 同步方法是将线程锁在了方法的外部，而同步代码块锁将线程锁在了代码块的外部，但是却是方法的内部

4.3  Lock锁

JDK1.5中推出了新一代的线程同步方式：Lock锁

【示例12】使用Lock锁实现线程同步

public class AccountRunnable implements  Runnable {
    private Account account = new Account();
    //买一把锁
    Lock lock = new ReentrantLock(); //Re-entrant-Lock  可重入锁
    @Override
    public void run() {
        //此处省略300句

        try{

//上锁
            lock.lock();
            //判断余额是否足够，够，取之；不够，不取之；
            if(account.getBalance()>=400){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                method1();
                //取之
                account.withDraw(400);
                //输出信息
                System.out.println(Thread.currentThread().getName()+
                   "取款成功，现在的余额是"+account.getBalance());
            }else{
    System.out.println("余额不足，"+Thread.currentThread().getName()
                 +"取款失败，现在的余额是"   +account.getBalance());
            }
        }finally {
            //解锁
            lock.unlock();
        }
        //此处省略100句
    }
}

• Lock锁
  • JDK1.5后新增功能，与采用synchronized相比，lock可提供多种锁方案，更灵活
  • java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象，它允许把锁定的实现作为 Java 类，而不是作为语言的特性来实现。这就为 Lock 的多种实现留下了空间，各种实现可能有不同的调度算法、性能特性或者锁定语义。
  • ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，  但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。
  • 注意：如果同步代码有异常，要将unlock()写入finally语句块
  • Lock和synchronized的区别
    • Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，遇到异常自动解锁
    • Lock只有代码块锁，synchronized有代码块锁和方法锁
    • Lock锁可以对读不加锁，对写加锁，synchronized不可以
    • Lock锁可以有多种获取锁的方式，可以从sleep的线程中抢到锁，synchronized不可以
    • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
    • 优先使用顺序：
      • Lock----同步代码块（已经进入了方法体，分配了相应资源）----同步方法（在方法体之外）

4.4  线程同步练习

实现三种线程同步方式实现多个窗口卖票，保证售票的安全性

【示例13】使用同步代码块实现多个窗口安全售票

public class TicketRunnable implements  Runnable{
    private int ticketNum = 100;
    private Object obj = new Object();
    public void run() {

        while(true){
            synchronized (obj){
                if(ticketNum<=0)
                    break;
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }     

              System.out.println(Thread.currentThread().getName()+

"卖出第"+ticketNum+"张票");
                ticketNum--;
            }
        }
    }
}

【示例14】使用同步方法实现多个窗口安全售票

public class TicketRunnable implements  Runnable{
    private int ticketNum = 100;
    @Override
    public void run() {

        while(true){
            sellOne();
            if(ticketNum ==0){
                break;
            }
        }
    }
    public synchronized void sellOne(){
        if(ticketNum==0){
           // break;
            return;
        }
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()

+"卖出第"+ticketNum+"张票");

        ticketNum--;
    }
}

【示例15】使用Lock锁实现多个窗口安全售票

public class TicketRunnable implements  Runnable{
    private int ticketNum = 100;
    private Lock lock = new ReentrantLock();
    public void run() {
        while(true){
            //上锁
            lock.lock();
            try{
                if(ticketNum==0){
                    break;
                }
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }       

          System.out.println(Thread.currentThread().getName()

+"卖出第"+ticketNum+"张票");
                ticketNum--;
            }
            finally {
                // 解锁
                lock.unlock();
            }
        }
    }
}