多线程之解决安全问题的三种情况

先奉上本博客内容整体逻辑框架图：

同步代码块

• 实现
  synchronized（）{};
• 同步技术原理:
  • 自定义锁对象，这个锁对象叫做同步锁，也叫对象监视器
  • 举例：
    三个线程一起去抢夺cpu的执行权，谁抢到谁就执行run方法进行卖票，t0抢到了CPU的执行 权，执行run方法，遇到synchronized代码块，这时t0会去检查synchronized代码块是否有锁对象，如果有，就获取到锁对象，进入到同步中执行，t1抢到了CPU的执行权，执行run方法，遇到synchronized代码块，这时t1会去检查synchronized代码块是否有锁对象，发现没有，t1就会进入阻塞状态，一直等待t0线程归还锁对象
• 同步技术总结
  - 同步保证了同一时刻只能有一个线程共享数据，解决了安全问题，但要频繁判断锁对象，效率低下
  - 同步中的线程，没有执行完毕就不会释放锁，同步外的线程没有锁进不去同步

package Xiancheng;

/**
 * 同步代码块
 * 买票出现了线程安全问题
 * 卖出了不存在或重复的票
 *
 * 解决方案：
 *  synchronized(锁对象){
 *      可能出现线程问题的代码
 *  }
 *  注意：
 *      1.通过代码块中的锁对象，可以是任意对象
 *      2.必须保证多个线程使用的锁对象是同一个
 *      3.锁对象作用：
 *              把同步代码块锁住，只让一个线程在同步代码块中执行
 */
public class Demo0417 implements Runnable{
    //定义一个多个线程共享的票源
    private int ticket=1000;
    //创建一个锁对象
    Object object=new Object();
    //设置线程任务：卖票
    @Override
    public void run() {
        //使用死循环，让卖票操作重复进行
        while(true){
            //同步代码块
           synchronized (object){
               //先判断票是否存在
               if(ticket>0){
                   //提高安全问题出现的概率，让程序睡眠
                   try {
                       Thread.sleep(500);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }

                   //票存在，卖票
                   System.out.println(Thread.currentThread().getName()+"-->正在卖票"+ticket+"张票");
                   ticket--;
               }
           }
        }
    }
    /**
     * 假设t1抢到了锁，就会执行if（） 然后进入睡眠时，t2会尝试进入同步，但发现没有锁，就会进入堵塞状态，等待
     * 当t1执行完一遍之后就会把锁归还，然后t1，t2，t3再重新抢夺锁的使用权，进行下一次循环
     * @param args
     */
    public static void main(String[] args) {
        Demo0417 demo0417=new Demo0417();
        Thread t1=new Thread(demo0417);
        Thread t2=new Thread(demo0417);
        Thread t3=new Thread(demo0417);
        t2.start();
        t1.start();
        t3.start();
    }
}

同步方法

• 步骤：
  • 把访问了共享数据的代码抽取出来，放在一个方法中
  • 把方法上添加synchronized修饰符
• 原理
  • 同步方法也会把方法内部代码锁住，只让一个线程执行。
  • 锁对象默认就是实例化对象（this）

package Xiancheng;

public class Demo0417 implements Runnable{
    //定义一个多个线程共享的票源
    private int ticket=1000;
    //创建一个锁对象
    Object object=new Object();
    //设置线程任务：卖票
    @Override
    public void run() {
        //使用死循环，让卖票操作重复进行
        while(true){
 			payTicket();
        }
    }
    //同步方法
public synchronized  void payTicket(){
    synchronized (this){
        //先判断票是否存在
        if(ticket>0){
            //提高安全问题出现的概率，让程序睡眠
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //票存在，卖票
            System.out.println(Thread.currentThread().getName()+"-->正在卖票"+ticket+"张票");
            ticket--;
        }
    }
}
    /**
     * 假设t1抢到了锁，就会执行if（） 然后进入睡眠时，t2会尝试进入同步，但发现没有锁，就会进入堵塞状态，等待
     * 当t1执行完一遍之后就会把锁归还，然后t1，t2，t3再重新抢夺锁的使用权，进行下一次循环
     * @param args
     */
    public static void main(String[] args) {
        Demo0417 demo0417=new Demo0417();
        Thread t1=new Thread(demo0417);
        Thread t2=new Thread(demo0417);
        Thread t3=new Thread(demo0417);
        t2.start();
        t1.start();
        t3.start();
    }
}

静态同步方法

• 基本与非静态相同，变量要求是静态变量
• 锁对象是本类的class属性 （class文件对象）

package Xiancheng;

public class Demo0417 implements Runnable{
    //定义一个多个线程共享的票源
    private static int ticket=1000;
    //创建一个锁对象
    Object object=new Object();
    //设置线程任务：卖票
    @Override
    public void run() {
        //使用死循环，让卖票操作重复进行
        while(true){
          payTicketStatic()
        }
    }
//静态同步方法
public static synchronized  void payTicketStatic(){
    synchronized (Demo0417.class){
        //先判断票是否存在
        if(ticket>0){
            //提高安全问题出现的概率，让程序睡眠
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //票存在，卖票
            System.out.println(Thread.currentThread().getName()+"-->正在卖票"+ticket+"张票");
            ticket--;
        }
    }
}
    /**
     * 假设t1抢到了锁，就会执行if（） 然后进入睡眠时，t2会尝试进入同步，但发现没有锁，就会进入堵塞状态，等待
     * 当t1执行完一遍之后就会把锁归还，然后t1，t2，t3再重新抢夺锁的使用权，进行下一次循环
     * @param args
     */
    public static void main(String[] args) {
        Demo0417 demo0417=new Demo0417();
        Thread t1=new Thread(demo0417);
        Thread t2=new Thread(demo0417);
        Thread t3=new Thread(demo0417);
        t2.start();
        t1.start();
        t3.start();
    }
}