19.2 线程同步和安全问题

买票案例：

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

步骤：

定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
在SellTicket类中重写run()方法实现卖票，代码步骤如下
判断票数大于0，就卖票，并告知是哪个窗口卖的
卖了票之后，总票数要减1
票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
创建SellTicket类的对象
创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
启动线程

实现代码：

public class SellTicket implements Runnable {
    private int ticketsNum = 100;

    @Override
    public void run() {
        sellTicket();
    }

    private void sellTicket() {
        while (true) {
            if (ticketsNum > 0) {
                try {
                    //实际生活中 买票会有延迟
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在出售第" + ticketsNum-- + "张票");
            } else {
                System.out.println("票已售罄");
                break;
        }
    }
}

测试类：

public class SellTicketsDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();

        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果:

 

卖票案例的问题

相同的票出现了多次 ：当有线程抢到执行权，执行的时候遇到sleep，这时候会有其他线程抢到执行权，但是票数还没有发生改变，这时候两个线程就会拿到同一张票
出现了负数的票：原因同上，当最后一张票被多个线程拿到，最后票数-- 的时候会减成负数

问题产生原因

线程执行的随机性导致的

安全问题出现的条件

是多线程环境
有共享数据
有多条语句操作共享数据

解决的方案:

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

解决的方案有三种

同步代码块、同步方法、lock锁

同步的好处和弊端 

好处：解决了多线程的数据安全问题 
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的 运行效率 

同步代码块格式：

同步方法的格式：就是把synchronized关键字加到方法上  同步方法锁 this

同步静态方法：就是把synchronized关键字加到静态方法上  同步静态方法锁 类名.class

JDK5以后提供了一个新的锁对象Lock

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

加锁解锁方法

 

代码演示：

/**
 * @PackageName: cn.itcast_1
 * @ClassName: SellTickets
 * @Author: LiLeNing
 * @Date: 2019/11/27 11:26
 * @Description: 买票    同步代码块、同步方法解决数据安全
 */
/**
 *  synchronized(任意对象) {     多条语句操作共享数据的代码 }
 *
 *  修饰符 synchronized 返回值类型 方法名(方法参数) {     方法体； }
 *  同步方法的锁对象是this
 *
 *  修饰符 static synchronized 返回值类型 方法名(方法参数) {     方法体；
 *  同步静态方法的锁对象是类名.class
 */
public class SellTickets implements Runnable{
    private static int ticketsNum = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        //给代码块加锁，一次只让一个线程进入
            /*synchronized (obj) {
                if (ticketsNum > 0) {
                    try {
                        //实际生活中 买票会有延迟
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + ticketsNum-- + "张票");
                } else {
                    System.out.println("票已售罄");
                    break;
                }
        }*/
        sellTicket();
    }

    //同步方法
    /*private synchronized void sellTicket() {
        while (true) {
            if (ticketsNum > 0) {
                try {
                    //实际生活中 买票会有延迟
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在出售第" + ticketsNum-- + "张票");
            } else {
                System.out.println("票已售罄");
                break;
            }
        }
    }*/

    //静态同步方法
    private static synchronized void sellTicket(){
        while (true) {
            if (ticketsNum > 0) {
                try {
                    //实际生活中 买票会有延迟
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在出售第" + ticketsNum-- + "张票");
            } else {
                System.out.println("票已售罄");
                break;
            }
        }
    }
}

测试类：

public class SellTicketsTest {
    public static void main(String[] args) {
        SellTickets st = new SellTickets();
        //SellTicketsLock st = new SellTicketsLock();

        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

lock锁代码演示：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * ReentrantLock() 创建一个ReentrantLock的实例
 * <p>
 * void lock() 获得锁
 * void unlock() 释放锁
 */
public class SellTicketsLock implements Runnable {
    private int ticketsNum = 100;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        sellTicket();
    }

    private void sellTicket() {
        while (true) {
            try {
                lock.lock();
                if (ticketsNum > 0) {
                    try {
                        //实际生活中 买票会有延迟
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + ticketsNum-- + "张票");
                } else {
                    System.out.println("票已售罄");
                    break;
                }
            } finally {
                lock.unlock();
            }

        }
    }
}