模拟买票问题讲解线程安全问题

实现买票案例
买票案例出现了线程问题，卖出了重复和不存在的票
解决线程安全问题的一种方法：使用同步代码块
格式：synchronized(锁对象){
可能出现线程问题的代码块（访问了共享数据的代码）
}
注意：1、通过代码块中的锁对象，可以使用任意对象
2、但是必须是保证多线程使用的锁对象是同一个
3、锁对象作用：把同步代码块锁住，只让一个线程在代码块中执行

public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private int ticket=100;
    //创建一个锁对象
    Object obj=new Object();//所的对象必须创建在run外面。创建在内部会出现多个锁对象
    //设置线程任务：买票
    @Override
    public void run() {
        //先判断票是否存在
        while (true){
            synchronized (obj){//同步代码块
                if(ticket>0){
                    //提高代码安全问题出现的机率，让程序睡眠
                    try{
                        Thread.sleep(10);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    //票存在,买票
                    System.out.println(Thread.currentThread().getName()+"-->"+"第"+ticket+"张票");
                    ticket--;
                }
            }
        }
    }
}

创建一个实现类

public class demoTicket {
    public static void main(String[] args) {
        //创建Runnable接口实现类对象
        RunnableImpl run=new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0=new Thread(run);
        Thread t1=new Thread(run);
        Thread t2=new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

解决线程问题的第二种方案

票案例出现了线程问题，卖出了不存在的票和重复的票
解决线程问题的第二种方案：使用同步方法
使用步骤：1、把访问了共享数据的代码抽取出来，放到一个方法中
2、在方法上添加synchronized修饰符
格式：定义方法的格式
修饰符 synchronized 返回值类型 方法名（参数列表）{
可能会出现线程安全问题的代码（访问共享数据的代码）
}

public class RunnableImpl implements Runnable{
    private int ticket=100;//定义一个多线程票源
    @Override//设置线程任务买票
    public void run() {//使用死循环让买票重复操作
        while(true){//判断票是否存在
            payTicked();
            }
        }
    public synchronized void payTicked(){//定义一个同步方法
        if(ticket>0){//提高安全问题让程序休眠
            try{
                Thread.sleep(10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            //票存在，买票
            System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
            ticket--;
        }
    }
}

创建一个main类

public class demo02Ticket {
        public static void main(String[] args) {
            //创建Runnable接口实现类对象
            RunnableImpl run=new RunnableImpl();
            //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
            Thread t0=new Thread(run);
            Thread t1=new Thread(run);
            Thread t2=new Thread(run);
            //调用start方法开启多线程
            t0.start();
            t1.start();
            t2.start();
        }
}

第三种解决线程安全方法：Lock锁

卖票案例出现了线程问题，卖出了不存在的票和重复的票
解决线程问题的第三种方案：使用Lock锁方法
java.util.concurrent.lock.locks。Lock接口
Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作
Lock接口中的方法：void lock（）;获取锁
void unlock();释放锁
java.util.concurrent.locks.reentrantLook implements Lock接口
使用步骤；1、在成员位置创建一个ReentrantLook对象
2、在可能出现安全问题的代码前调用Lock接口中的方法lock获取锁
3、在可能出现安全问题的代码后调用Lock接口中的方法unlock释放锁

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class RunnableImpl implements Runnable{
    private int ticket=100;//定义一个多线程票源
    Lock l=new ReentrantLock();
    @Override//设置线程任务买票
    public void run() {//使用死循环让买票重复操作
        while(true){//判断票是否存在
            l.lock();
            if(ticket>0){//提高安全问题让程序休眠
                try{
                    Thread.sleep(10);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                //票存在，买票
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
            l.unlock();
        }
    }
}

创建一个测试类

public class demo02Ticket {
        public static void main(String[] args) {
            //创建Runnable接口实现类对象
            RunnableImpl run=new RunnableImpl();
            //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
            Thread t0=new Thread(run);
            Thread t1=new Thread(run);
            Thread t2=new Thread(run);
            //调用start方法开启多线程
            t0.start();
            t1.start();
            t2.start();
        }
}