逐渐深入线程安全问题及线程的同步

–引入线程安全
我们在售票的时候，可能会出现"意外情况"，例如，一张票被打印多次，或者打印出的票数为0甚至为负数。这些情况都是有多线程操作共享资源所导致的线程安全问题。
引例：

class SaleThread implements Runnable{
    private int tickets=10;
    public void run(){
        while(true){
            if(tickets>0){
                try {
                    Thread.sleep(100);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()
                        +"正在发售"+tickets--+"张票");
            }
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        SaleThread saleThread=new SaleThread();
        //创建并开启4个线程，模拟4个售票窗口
        new Thread(saleThread,"黄牛1").start();
        new Thread(saleThread,"黄牛2").start();
        new Thread(saleThread,"黄牛3").start();
        new Thread(saleThread,"黄牛4").start();
    }
}

运行结果：

为何会出现这种现象呢？
在售票程序中的while循环中添加了sleep()方法，这样就模拟了售票过程中线程的延迟。由于线程有延迟，假设while循环后，现在还剩1张票，此时进入if(tickets>0)语句，然而这时线程需要休眠，此时由于票数仍然为1，另一个线程就进入了if(tickets>0)语句，所以这样会出现有问题的票数。
这个时候我们发现，票数竟然出现负数，这种问题我们称之为不同步操作。
不同步的唯⼀好处是处理速度快（多个线程并发执⾏）
线程安全的概念：
想给出一个线程安全的确切定义是复杂的，但我们可以这样认为：
如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。
关注1：原子性
一个操作或者多个操作，要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
原子性是指操作是不可分的。其表现在于对于共享变量的某些操作，应该是不可分的，必须连续完成。
例如a++，对于共享变量a的操作，实际上会执行三个步骤：
1.读取变量a的值
2.a的值+1
3.将值赋予变量a 。
这三个操作中任何一个操作过程中，a的值被人篡改，那么都会出现我们不希望出现的结果。所以我们必须保证这是原子性的。Java中的锁的机制解决了原子性的问题。
一条 java 语句不一定是原子的，也不一定只是一条指令
不保证原子性会给多线程带来什么问题
如果一个线程正在对一个变量操作，中途其他线程插入进来了，如果这个操作被打断了，结果就可能是错误的。
关注2：可见性
可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
所有的变量都存储在主内存中。
每个线程都有自己独立的工作内存，里面保存该线程使用到的变量的副本（主内存中该变量的一份拷贝）。线程对共享变量的所有操作都必须在自己的工作内存，不能直接从相互内存中读写也不能从主内存中操作。
要实现共享变量的的可见性，必须保证两点：

    1)线程修改后的共享变量值能够及时从工作内存刷新到主内存中。

    2)其他线程能够及时把共享变量的最新值从主内存更新到自己的工作内存中。

可见性的实现方式：

    语言层面支持的可见性实现方式：

    1)使用关键字synchronized

    2)使用关键字volatile

    final也可以保证内存可见性

关注3：重排序
一段代码是这样的：
1.去前台取下 U 盘
2.去教室写 10 分钟作业
3.去前台取下快递
如果是在单线程情况下，JVM、CPU指令集会对其进行优化，比如，按 1->3->2的方式执行，也是没问题，可以少跑一次前台。这种就是指令的重排序。
一.解决线程不安全问题的方法–同步处理
线程安全问题其实就是多个线程同时处理共享资源所造成的。
解决线程安全问题的方法：
1>同步代码块

synchronized(锁的对象||Object及其子类||对象类){

}

注意：
同步代码块中的锁对象可以是任意类型的对象，但多个线程共享的锁对象必须是相同的。

示例1：

package synchronization;
class SaleThread2 implements Runnable{
    private int tickets=10;
    public void run(){
        while(true){
            synchronized(this){
                if(tickets>0){
                    try {
                        Thread.sleep(100);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()
                            +"正在发售"+tickets--+"张票");
                }
            }
        }
    }
}
public class Demo3 {
    public static void main(String[] args) {
        SaleThread2 saleThread2=new SaleThread2();
        //创建并开启4个线程，模拟4个售票窗口
        new Thread(saleThread2,"黄牛1").start();
        new Thread(saleThread2,"黄牛2").start();
        new Thread(saleThread2,"黄牛3").start();
        new Thread(saleThread2,"黄牛4").start();
    }
}

运行结果：

2>同步方法

public synchronized void saleTickets();
这里默认锁的是this，直接在方法声明上使用synchronized，
此时表示同步方法在任意时刻只能有一个线程进入。

思考：
同步代码块中的锁是自己定义的任意类型的对象，同步方法中的锁就是当前调用该方法的对象，也就是this指向的对象。
有时同步的是静态方法，静态方法不需要创建对象就可以直接使用"类名.方法名()"直接调用。在这里，静态方法的锁是该方法所在类的class对象，该对象直接用"类名.class"的方式获取。
同步代码块和同步方法解决多线程问题有好处也有弊端。线程在执行同步代码时每次都会判断锁的状态，非常消耗资源，效率较低。
例2：

class SaleThread3implements Runnable{
    private int tickets=10;
    public void run(){
        while(true){
            saleTickets();
        }
    }
    private synchronized void saleTickets(){
        if(tickets>0){
            try {
                Thread.sleep(100);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()
                    +"正在发售"+tickets--+"张票");
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        SaleThread2 saleThread2=new SaleThread2();
        //创建并开启4个线程，模拟4个售票窗口
        new Thread(saleThread3,"黄牛1").start();
        new Thread(saleThread3,"黄牛2").start();
        new Thread(saleThread3,"黄牛3").start();
        new Thread(saleThread3,"黄牛4").start();
    }
}

运行结果：

3>锁机制
二.synchronized使用场景
synchronized的底层是使用操作系统的mutex lock实现的。
当线程释放锁时，JMM会把该线程对应的工作内存中的共享变量刷新到主内存中
当线程获取锁时，JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须从主内存中读取共享变量。

//锁的 SynchronizedDemo 对象
public class SynchronizedDemo {
    public synchronized void methond() {

    }
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        demo.method(); // 进入方法会锁 demo 指向对象中的锁；出方法会释放 demo 指向的对象中的锁
        }
}

//锁的 SynchronizedDemo 类的对象
public class SynchronizedDemo {
    public synchronized static void methond() {

    }
    public static void main(String[] args) {
        method(); // 进入方法会锁 SynchronizedDemo.class 指向对象中的锁；出方法会释放 SynchronizedDemo.class 指向的对象中的锁
    }
}

//明确锁的对象
public class SynchronizedDemo {
    public void methond() {
        // 进入代码块会锁 this 指向对象中的锁；出代码块会释放 this 指向的对象中的锁 synchronized (this) {
        }
}
public static void main(String[] args) {
    SynchronizedDemo demo = new SynchronizedDemo();
    demo.method();
    }
}

public class SynchronizedDemo {
    public void methond() {
        // 进入代码块会锁 SynchronizedDemo.class 指向对象中的锁；出代码块会释放 SynchronizedDemo.class 指向的对象中的锁
        synchronized (SynchronizedDemo.class) {

        }
    }
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        demo.method();
    }
}