线程安全问题的三种解决方案具体实现——以卖票为案例

本文链接：https://blog.youkuaiyun.com/zuoyou_yi/article/details/105424183

解决安全问题的三种方案：使用代码块、使用同步方法、使用Lock锁

1.解决安全问题第一种方案：使用代码块

格式：synchronized（锁对象）{
可能会出现线程安全问题的代码（范文了共享数据的代码）
}
注意：
1.通过代码块中的锁对象，可以使用任意的对象
2.但是必须保证多个线程使用的锁对象是同一个
3.锁对象作用：
把同步代码块锁住，只让一个线程在同步代码块中执行

package Demo_Synchronized;

public class RunnableImpl implements Runnable{
    //定一个一个多线程共享的票源
    private int ticket=100;
    //创建一个锁对象
    Object obj=new Object();

    //设置线程任务：卖票
    @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--;
                    }
                }
        }
    }
}

2.解决安全问题第二种方案，使用同步方法（包含静态的同步方法）

使用步骤：
    1.把访问了共享数据的代码抽取出来，放在一个方法中
    2.在方法上添加synchronized修饰符
格式：定义方法的格式
修饰符synchronized 返回值类型方法名（参数列表）{
    可能会出现线程安全的代码（访问了共享数据的代码）
}

package Demo_Synchronized01;

public class RunnableImpl implements Runnable{
    //定一个一个多线程共享的票源
    private int ticket=100;
    //private static int ticket  =100;
    //创建一个锁对象
    Object obj=new Object();

    //设置线程任务：卖票
    @Override
    public void run() {
        System.out.println("this:"+this);
        //判断票是否存在


            while (true){
                    payTicket();
                }
        }
        /*
            定义一个同步方法
            同步方法也会把方法内部的代码锁住
            只让一个线程运行
            同步方法的锁对象是谁？
            就是实现类对象 new RunnableImpl（）
            也就是this
         */
        public synchronized void payTicket(){
            //同步代码块
            synchronized (obj){
                if(ticket>0){
                    //提高安全问题出现的概率，让程序睡眠
                    try {
                        Thread.sleep(10);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"-->"+"正在卖第"+ticket+"张票");
                    ticket--;
                }
        }
    }

        /*
            静态的同步方法
            锁对象是谁？
            不能是this
            this是创建对象后产生的，静态方法优先于对象
            静态方法的锁对象是本类的class属性--》class文件对象（反射）
         */
//        public static synchronized void payTicketstaic(){
//            //同步代码块
//            //synchronized (obj){
//                if(ticket>0){
//                    //提高安全问题出现的概率，让程序睡眠
//                    try {
//                        Thread.sleep(10);
//                    }catch (InterruptedException e){
//                        e.printStackTrace();
//                    }
//                    System.out.println(Thread.currentThread().getName()+"-->"+"正在卖第"+ticket+"张票");
//                    ticket--;
//                }
//            //}
//        }

}

3.解决安全问题第三种方案：使用Lock锁

java.util.concurrent.locks
Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作
Lock接口中的方法：
    void lock() 获得锁。
    void unlock() 释放锁。
    java.util.concurrent.locks.ReentrantLock implements Lock接口
    使用步骤：
        1.在成员位置创建一个ReentrantLock对象
        2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
        3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁

package Demo_Lock;

import java.util.concurrent.locks.ReentrantLock;

public class RunnableImpl implements Runnable{
    //定一个一个多线程共享的票源
    private int ticket=100;
    //1.在成员位置创建一个ReentrantLock对象
    ReentrantLock l1=new ReentrantLock();

    @Override
    public void run() {

        //判断票是否存在
        while (true){
            //2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
            l1.lock();
            //同步代码块
            if(ticket>0){
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName()+"-->"+"正在卖第"+ticket+"张票");
                    ticket--;
                }catch (InterruptedException e){
                    e.printStackTrace();
                }finally {
                    //3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁
                    l1.unlock();//无论程序是否异常，都释放掉锁

            }
        }
    }
    }

}

测试类

package Demo_Synchronized01;

/*
    模拟买票的案例
    创建三个线程同时开启，对共享的票进行出售
 */
public class DemoTicket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run=new RunnableImpl();
        System.out.println("run:"+run);
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0=new Thread(run);
        Thread t1=new Thread(run);
        Thread t2=new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

来自黑马教程