同步与死锁

一 、问题引出

  一个多线程的程序如果通过 Runnable 接口实现，则意味着类中的属性可被多个线程共享，那么在实际应用中，比如卖票程序，在网络延迟等情景下，就有可能出现问题。即多个线程对象同时操作同一共享资源

class MyThread implements Runnable{
    private int ticket = 5;
    public void run(){
        for (int i=0;i<100;i++){
            if(ticket>0){        //判断是否有余票
                try {
                    Thread.sleep(300);  //模拟网络延迟
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("卖票：ticket = " + ticket--);   //卖票
            }
        }
    }
}

public class RunnableDemo03 {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t1 = new Thread(mt);
        Thread t2 = new Thread(mt);
        Thread t3 = new Thread(mt);
        t1.start();
        t2.start();
        t3.start();
    }
}

程序运行结果：

观察程序结果发现，运行的最后出现了负数的情况，为什么会产生这样的问题呢？

以上程序运行分为两个步骤：（1）、判断是否票数大于0，大于0则可卖 （2）进行票数减1
但在这两个步骤之间加入了延迟
当多个线程对象对同一个共享资源进行操作，有可能一个线程对象还未进行减1操作时，另一个线程对象也取出同一资源进行操作，这样一来就会出现票数为负的情况

二 、解决思路

  要想解决这样的问题，就必须使用同步。所谓同步就是指多个操作在同一时间段内只能有一个线程进行，其它线程要等待此线程完成之后才可继续执行

三 、使用同步解决问题

解决资源共享的同步操作，可以使用 同步代码块 和 同步方法 两种方式完成

1 、同步代码块
在《面向对象（基础篇）第6篇 -----main 方法与代码块》博客中有三种代码块的笔记：

代码块 是指使用 “ {} ”括起来的一段代码，根据位置不同，代码块可分为普通代码块，构造块，静态代码块。如果在代码块上加上 synchronized 关键字，则此代码块就称为 同步代码块
【格式】
synchronized (同步对象) {    //一般都将当前对象（this）设置成同步对象
   需要同步的代码
}

class MyThread implements Runnable{
    private int ticket = 5;
    public void run(){
        for (int i=0;i<100;i++){
            synchronized (this){     //设置需要同步的操作
                if(ticket>0){        //判断是否有余票
                    try {
                        Thread.sleep(300);  //模拟网络延迟
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("卖票：ticket = " + ticket--);   //卖票
                }
            }
        }
    }
}

public class RunnableDemo03 {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t1 = new Thread(mt);
        Thread t2 = new Thread(mt);
        Thread t3 = new Thread(mt);
        t1.start();
        t2.start();
        t3.start();
    }
}

程序运行结果：

以上代码将卖票操作进行同步，所以不会出现卖出票数为负数的情况


2 、同步方法
使用 synchronized 关键字 将一个方法声明为同步方法

class MyThread implements Runnable{
    private int ticket = 5;
    public void run(){
        for (int i=0;i<100;i++){
                this.saleTicket();  //调用同步方法
        }
    }
    public synchronized void saleTicket(){  //声明同步方法
        if(ticket>0){        //判断是否有余票
            try {
                Thread.sleep(300);  //模拟网络延迟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("卖票：ticket = " + ticket--);   //卖票
        }
    }
}

public class RunnableDemo03 {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t1 = new Thread(mt);
        Thread t2 = new Thread(mt);
        Thread t3 = new Thread(mt);
        t1.start();
        t2.start();
        t3.start();
    }
}

程序运行结果：

死锁

  同步可以保证资源共享操作的正确性，但是过多同步也会产生问题。例如：A想要B手中的铅笔，B想要A手中的橡皮檫，A对B说：“你把你的铅笔给我，我就给你橡皮檫”，而B对A说：“你把你的橡皮檫给我，我就把铅笔给你”，此时，双方都在等待对方的操作，这样一直僵持下去，这就是死锁的概念

所谓的死锁是指两个线程都在等待彼此完成，造成程序的停滞

总结：

  多个线程共享同一个资源需要进行同步，以保证资源操作的完整性，但是过多的同步就有可能产生死锁