3. 线程同步

1. 卖票案例

案例需求

某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

定义一个类Tickets实现Runnable接口，里面定义一个成员变量：private int tickets = 100;

在Tickets类中重写run()方法实现卖票

package com.zhang.threaddemoes.saleoftickets;

/**
 * 三个线程销售一百张票
 */
public class Tickets implements Runnable{
    /**
     * 多条线程同时操作同一份数据
     */
    private int tickets = 100;


    @Override
    public void run() {
        while (true){
            //如果票数小于等于0，跳出循环
                if(tickets <= 0){
                    break;
                }else {
                    //卖了一张票，减1
                    tickets--;
       System.out.println(Thread.currentThread().getName() + " 在卖票,还剩" +tickets + " 张票" );
                
               }
        }
    }
}

• 创建Tickets类的对象
• 创建三个Thread类的对象，把Tickets对象作为构造方法的参数，并给出对应的窗口名称
• 启动线程

package com.zhang.threaddemoes.saleoftickets;

public class SaleOfTickets {

    public static void main(String[] args) {

        /**
         * 三条线程操作同时操作同一份数据
         */
        Tickets tickets = new Tickets();

        Thread thread1 = new Thread(tickets);
        Thread thread2 = new Thread(tickets);
        Thread thread3 = new Thread(tickets);


        thread1.setName("窗口一");
        thread2.setName("窗口二");
        thread3.setName("窗口三");

        //启动线程
        thread1.start();
        thread2.start();
        thread3.start();
    }

}

2.卖票案例的问题

假如在代码中，在票数减1的前面让线程休眠

package com.zhang.threaddemoes.saleoftickets;

/**
 * 三个线程销售一百张票
 */
public class Tickets implements Runnable{

    /**
     * 多条线程同时操作同一份数据
     */
    private int tickets = 100;

    @Override
    public void run() {
        while (true){
                if(tickets <= 0){
                    break;
                }else {

                    try {
                        Thread.sleep(100);//线程休眠
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    tickets--;
                System.out.println(Thread.currentThread().getName() + " 在卖票,还剩" +tickets + " 张票" );
                }
            
        }
    }
}

就会出现如下问题：

• 卖票出现了问题

  • 相同的票出现了多次

  • 出现了负数的票

• 问题产生原因

  线程执行的随机性导致的,可能在卖票过程中丢失cpu的执行权,导致出现问题

3.同步代码块解决数据安全问题

• 安全问题出现的条件

  • 是多线程环境

  • 有共享数据

  • 有多条语句操作共享数据

• 如何解决多线程安全问题呢?

  • 基本思想：让程序没有安全问题的环境

• 怎么实现呢?

  • 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

  • Java提供了同步代码块的方式来解决

  • 同步代码块格式：

    synchronized(任意对象) { 
    	多条语句操作共享数据的代码 
    }
    

    synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

  • 同步的好处和弊端

    • 好处：解决了多线程的数据安全问题

    • 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

  • 代码演示

package com.zhang.threaddemoes.saleoftickets;

/**
 * 三个线程销售一百张票
 */
public class Tickets implements Runnable{

    /**
     * 多条线程同时操作同一份数据
     */
    private int tickets = 100;


    @Override
    public void run() {
        while (true){

            synchronized (Tickets.class){// 对可能有安全问题的代码加锁,多个线程必须使用同一把锁
                //t1进来后，就会把这段代码给锁起来
                if(tickets <= 0){
                    break;
                }else {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    tickets--;
               System.out.println(Thread.currentThread().getName() + " 在卖票,还剩" +tickets + " 张票" );
                }
            }
             //t1出来了，这段代码的锁就被释放了
        }
    }
}

4.同步方法解决数据安全问题

• 同步方法的格式

  同步方法：就是把synchronized关键字加到方法上

  修饰符 synchronized 返回值类型 方法名(方法参数) { 
  	方法体；
  }
  

  同步方法的锁对象是什么呢?

  ​ this

• 静态同步方法

  同步静态方法：就是把synchronized关键字加到静态方法上

  修饰符 static synchronized 返回值类型 方法名(方法参数) { 
  	方法体；
  }
  

  同步静态方法的锁对象是什么呢?

  ​ 类名.class

  5. Lock锁

  虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

  Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

  • ReentrantLock构造方法

    方法名	说明
    ReentrantLock()	创建一个ReentrantLock的实例

  • 加锁解锁方法

    方法名	说明
    void lock()	获得锁
    void unlock()	释放锁

  • 代码演示

  package com.zhang.threaddemoes.saleoftickets;
  
  import java.util.concurrent.locks.ReentrantLock;
  
  /**
   * 三个线程销售一百张票
   */
  public class Tickets3 implements Runnable {
  
      /**
       * 多条线程同时操作同一份数据
       */
      private int tickets = 100;
      private ReentrantLock lock = new ReentrantLock();
  
  
      @Override
      public void run() {
  
          while (true) {
              try {
                  lock.lock();
                  if(tickets <= 0){
                      break;
                  }else{
                      Thread.sleep(100);
                      tickets--;
                      System.out.println(Thread.currentThread().getName() + "在卖票，还剩"+tickets+" 张");
                  }
              } catch (Exception e) {
                  e.printStackTrace();
              } finally {
                  lock.unlock();
              }
          }
      }
  }
  
  

测试类

package com.zhang.threaddemoes.saleoftickets;

public class Demo3 {
    public static void main(String[] args) {
        Tickets3 tickets3 = new Tickets3();

        Thread thread1 = new Thread(tickets3);
        Thread thread2 = new Thread(tickets3);
        Thread thread3 = new Thread(tickets3);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}