Java 之 线程安全（线程同步）

一、线程安全

　　当有多个线程同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，这就是线程安全的。

　　下面通过一个案例来演示线程的安全问题。

　　模拟电影票买票的过程，其中，一共有100张票。下面来模拟电影票的售票窗口，实现多个窗口同时卖票，采用线程对象来模拟，通过实现 Runnable 接口子类来模拟。

　　Demo：

// 模拟票
public class Ticket implements Runnable {
    private int ticket = 100;
    /*
    * 执行卖票操作
    */
    @Override
    public void run() {
        //每个窗口卖票的操作
        //窗口 永远开启
        while (true) {
            if (ticket > 0) {//有票 可以卖
                //出票操作
                //使用sleep模拟一下出票时间
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // TODO Auto‐generated catch block
                    e.printStackTrace();
                }
                //获取当前线程对象的名字
                String name = Thread.currentThread().getName();
                System.out.println(name + "正在卖:" + ticket+"张票");
　　　　　　　　　　　　ticket--;
            }
        }
    }
}
// 测试类
public class Demo {
    public static void main(String[] args) {
        //创建线程任务对象
        Ticket ticket = new Ticket();
        //创建三个窗口对象
        Thread t1 = new Thread(ticket, "窗口1");
        Thread t2 = new Thread(ticket, "窗口2");
        Thread t3 = new Thread(ticket, "窗口3");
        //同时卖票
        t1.start();
        t2.start();
        t3.start();
    }
}

　　结果中有一部分这样现象：

 　　发现程序出现了两个问题

　　　　① 相同的票数，比如5这张票被卖了两次。

　　　　② 不存在的票，比如 0 和 -1票，是不存在的。

　　　为什么出现这样的情况呢？

　　　当只有一个窗口售票或多个窗口分别出售自己的票是没有问题的。但是当三个窗口，同时访问共享的资源，就会导致线程不同步，这种问题称为线程不安全。

 　　线程安全问题产生的原理：

　　

　　注意：线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量，静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

二、线程同步

　　 当使用过个线程访问统一资源的时候，且多个线程中对资源有些的操作，就容易出现线程安全问题。

　　 要解决上述多线程并发访问一个资源的安全性问题：也就是解决重复票与不存在票的问题。Java 中提供了同步机制（synchronized）来解决。

　　 以上面的售票案例来简述一下同步机制：

　当窗口1线程进入操作的时候，窗口2和窗口3线程只能在外面等着，窗口1操作结束，窗口1、窗口2和窗口3才有机会进入代码去执行。
 也就是说某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

　　   同步原理图解：

　　为了保证每个线程都能正常执行原子操作，Java 引入线程同步机制，下面学习三种同步机制。

　　1、同步代码块方法

　　　　同步代码块：synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

　　　　语法格式：

synchronized(同步锁){
    需要同步操作的代码 / 可能会出现线程安全问题的代码（访问共享数据的代码）
}

　　　　同步锁：对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁。

　　　锁对象：又称为监视器对象，同一时刻，某一段代码，只允许一个线程允许，其他线程进不来。

　　　注意：

　　　　　① 代码块中的锁对象,可以使用任意的对象

　　　　　② 必须保证多个线程使用的锁对象是同一个

　　　　　③ 锁对象作用：把同步代码块锁住,只让一个线程在同步代码块中执行

　　　　　④ 在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着 （Blocked）

　　　Demo : 使用同步代码块解决上面售票问题

　　 （1）使用 Thread 类实现

class Ticket extends Thread{
    private static int total = 100;
    private static Object lock = new Object();//锁的选择之一，单独造一个锁对象
    
    public Ticket(String name) {
        super(name);
    }

    public void run(){
    //    synchronized (this) {//这里使用this不行，因为这个this，对于三个线程来说不是同一个
        while(true){
            synchronized (lock) {
                if(total > 0){
                    System.out.println(getName() + "卖出一张票");
                    total--;
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("剩余：" + total);
                }else{
                    break;
                }
            }
        }
    }
}

　　（2）使用 Runnable接口 实现：方式一

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();
                    }

                    //票存在,卖票 ticket--
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                }
            }
        }
    }
}

　　　　方式二：使用 this 锁

class Ticket implements Runnable{
    private int total = 10;

    @Override
    public void run() {
        while(true){
            synchronized (this) {//选择this当锁，可以，因为只有一个Ticket的对象
                if(total>0){
                    System.out.println(Thread.currentThread().getName() +"卖出一张票");
                    total--;
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("剩余：" + total);
                }else{
                    break;
                }
            }
        }
    }
    
}

　　2、同步方法

　　　　同步方法：使用 synchronized 修饰的方法，就叫做 同步方法，保证一个线程执行该方法的时候，其他线程只能在方法外等着。

　　　　语法格式：

【修饰符】 synchronized 返回值类型 方法名(【参数列表】){
    可能会产生线程安全问题的代码 / 可能会出现线程安全问题的代码(访问了共享数据的代码)
}

　　　　　注意：同步方法的锁对象，程序员无法选择：

　　　　　　（1）对于非静态的方法，同步锁就是实现类对象，也就是 this。

　　　　　　（2）对于静态方法，同步锁对象就是当前类的 Class 对象。

　　　　Demo：使用同步方法解决售票问题。

　　　　（1）使用 Thread 类实现

class Ticket extends Thread{
    private static int total = 100;
    
    public Ticket(String name) {
        super(name);
    }

    public void run(){
        while(total>0){//程序停止的条件
            saleOneTicket();
        }
    }
    
    //非静态方法的锁对象是this，这里使用this，不是合格的锁对象
    //使用非静态方法，当前锁对象是 当前的 Class 对象
    public synchronized static void saleOneTicket(){
        if(total > 0){//线程安全问题的条件
            System.out.println(Thread.currentThread().getName() + "卖出一张票");
            total--;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("剩余：" + total);
        }
    }
}

　　　　（2）使用 Runnable 接口实现

public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private int ticket = 100;


    //设置线程任务:卖票
    @Override
    public void run() {
        System.out.println("this:"+this);10         //使用死循环,让卖票操作重复执行
        while(true){
            payTicketStatic();
        }
    }

    /*
        定义一个同步方法
        同步方法也会把方法内部的代码锁住
        只让一个线程执行
        同步方法的锁对象是谁?
        就是实现类对象 new RunnableImpl()
        也是就是this
     */
    public /*synchronized*/ void payTicket(){
        synchronized (this){   //这里可以使用 this 锁对象
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }

    }
}

　　　　还可以把同步方法声明为一个静态的方法：

　　　　语法格式：

public static synchronized void method(){
    可能会产生线程安全问题的代码 / 可能会出现线程安全问题的代码(访问了共享数据的代码)
}

　　　　　注意：对于 static方法,锁对象就是使用当前方法所在类的字节码对象(类名.class)。

　　　　　Demo：使用 static 同步方法解决售票问题。

public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private static int ticket = 100;

    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
            payTicketStatic();
        }
    }

    /*
        静态的同步方法
        静态方法的锁对象是本类的class属性-->class文件对象(反射)
     */
    public static /*synchronized*/ void payTicketStatic(){
        synchronized (RunnableImpl.class){
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }

    }

}

　　3、Lock 锁

　　　　java.util.concurrent.locks.Lock 机制提供了比 synchronized 代码块和 synchronized 方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

　　　　Lock 锁也称同步锁，方法如下：

public void lock() :加同步锁。
public void unlock() :释放同步锁。

　　　　　使用步骤：

　　　　　　① 在成员位置创建一个ReentrantLock对象（Lock接口的一个实现类）

　　　　　　② 在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁

　　　　　　③ 在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

　　　　Demo：

public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //1.在成员位置创建一个ReentrantLock对象
    Lock l = new ReentrantLock();

    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
            //2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
            l.lock();

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

三、死锁

　　1、死锁概念

　　　　死锁：死锁是指两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

　  2、死锁的必要条件

　　　　死锁的发生也必须具备一定的条件，死锁的发生必须具备以下四个必要条件

　　　　1）互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。

　　　　2）请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。

　　　　3）不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。

　　　　4）环路等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。