多线程实现同步（第二天）

线程安全

当多个线程同时共享，同一个全局变量或静态变量，做写的操作时，可能会发生数据冲突问题，也就是线程安全问题。但是做读操作是不会发生数据冲突问题。

线程如何实现同步

同步的前提

1. 必须要有两个或者两个以上的线程。
2. 必须是多个线程使用同一个锁
3. 必须保证同步中只能有一个线程在运行
4. 好处：解决了多线程的安全问题
5. 弊端：多个线程需要判断锁，较为消耗资源、抢锁的资源。

实现同步的几种方式

package top.nightliar.study.day02;

/**
 * Created by Nightliar
 * 2018-09-12 16:37
 */
public class ThreadDemo01 {

    public static void main(String[] args) {
        ThreadTrain threadTrain = new ThreadTrain();
        Thread t1 = new Thread(threadTrain, "窗口1");
        Thread t2 = new Thread(threadTrain, "窗口2");
        t1.start();
        t2.start();
    }
}

package top.nightliar.study.day02;

/**
 * Created by Nightliar
 * 2018-09-12 16:40
 */
public class ThreadTrain implements Runnable{

    private static int count = 100;  //火车票总数

    private Object ob = new Object();  //锁对象

    @Override
    public void run() {
        while (count > 0){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //出售火车票
            sale();
        }
    }

    //售票方法
    private void sale(){
        if (count > 0){
            System.out.println(Thread.currentThread().getName() + "，出售第" + (100 - count + 1) + "张票");
            count-- ;
        }
    }
}

• 同步代码块
  使用synchronized将可能会发生线程安全问题的代码，给包括起来。

synchronized(同一个数据){
    可能会发生线程冲突问题
}

• 同步函数
  在方法上修饰synchronized 称为同步函数，同步函数使用的是this锁。

    //加了同步代码块的售卖方法
    private void sale(){
        synchronized (ob){
            if (count > 0){
                System.out.println(Thread.currentThread().getName() + "，出售第" + (100 - count + 1) + "张票");
                count-- ;
            }
        }
    }

• 静态同步函数
  方法上加上static关键字，使用synchronized 关键字修饰，静态的同步函数使用的锁是该函数所属字节码文件对象。

    //同步静态方法的售卖方法
    private static synchronized void sale(){
        if (count > 0){
            System.out.println(Thread.currentThread().getName() + "，出售第" + (100 - count + 1) + "张票");
            count-- ;
        }
    }

线程死锁示例

同步中嵌套同步，导致锁无法释放，线程无法得到自己需要的锁，也不释放别人需要的锁，导致两个线程无限等待锁资源。

package top.nightliar.study.day02;

/**
 * 线程死锁示例
 * Created by Nightliar
 * 2018-09-12 17:46
 */
public class DeadLock implements Runnable {

    boolean flag = false;
    //ob1,ob2为两个静态的锁
    private static Object ob1 = new Object();
    private static Object ob2 = new Object();

    public DeadLock(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if (flag){
            while (true) {
                synchronized (ob1){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (ob2){
                        System.out.println("进入到true");
                    }
                }
            }
        }else {
            while (true) {
                synchronized (ob2){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (ob1){
                        System.out.println("进入到false");
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        DeadLock deadLock1 = new DeadLock(false);
        DeadLock deadLock2 = new DeadLock(true);
        new Thread(deadLock1).start();
        new Thread(deadLock2).start();
    }

}

多线程的三大特性

原子性

即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。只有线程具备原子性，在多线程下才能保证不出现一些问题。
例如：i = i+1；其中就包括，读取i的值，计算i，写入i。这行代码在Java中是不具备原子性的，则多线程运行肯定会出问题，所以也需要我们使用同步和lock这些东西来确保这个特性了。
原子性用来保证数据的一致性，是线程安全的一部分。

可见性

当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
若两个线程在不同的cpu，那么线程1改变了i的值还没刷新到主存，线程2又使用了i，那么这个i值肯定还是之前的，线程1对变量的修改线程没看到这就是可见性问题。

有序性

程序执行的顺序按照代码的先后顺序执行。
一般来说处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。
重排序对单线程没有影响，但多线程情况下就有可能出现问题。

java内存模型（多线程可见性）

java内存模型决定了一个线程与另一个线程是否可见。
java内存模型：主内存（主要存放共享的全局变量），私有本地内存（本地线程私有变量）。
工作流程：私有本地内存持有主内存中全局变量的副本，在当前线程中修改后，刷新到主内存中。在线程中使用的全局变量都是使用的私有内存中所持有的副本，所以当一个线程将全局变量修改后，其余线程不会及时得到最新值，而是使用副本值。可以使用volatile来保证线程每次使用该值时都从主内存中拿到最新值，而不是是用副本值。

Volatile

保证线程可见性，但不保证原子性。

package top.nightliar.study.day02;

/**
 * Created by Nightliar
 * 2018-09-13 10:10
 */
public class ThreadDemo02 extends Thread {

    private boolean flag = true;
//    private volatile boolean flag = true;

    @Override
    public void run() {
        System.out.println("开始执行子线程....");
        while (flag) {
        }
        System.out.println("线程停止");
    }

    public void setRuning(boolean flag) {
        this.flag = flag;
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadDemo02 threadVolatileDemo = new ThreadDemo02();
        threadVolatileDemo.start();
        Thread.sleep(3000);
        threadVolatileDemo.setRuning(false);
        System.out.println("flag 已经设置成false");
        Thread.sleep(1000);
        System.out.println(threadVolatileDemo.flag);
        //没有使用volatile时，线程会一直运行
    }

}

ThreadLocal

ThreadLocal提高一个线程的局部变量，访问某个线程拥有自己局部变量。
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

ThreadLocal的作用和目的

用于实现线程内的数据共享，即对于相同的程序代码，多个模块在同一个线程中运行时要共享一份数据，而在另外线程中运行时又共享另外一份数据。

ThreadLocal的原理

每个线程调用全局 ThreadLocal 对象的 set 方法，在 set 方法中，首先根据当前线程获取当前线程的ThreadLocalMap 对象，然后往这个map中插入一条记录，key 其实是ThreadLocal对象，value是各自的set方法传进去的值。
也就是每个线程其实都有一份自己独享的 ThreadLocalMap对象，该对象的 Key 是 ThreadLocal对象，值是用户设置的具体值。
在线程结束时可以调用 ThreadLocal.remove()方法，这样会更快释放内存，不调用也可以，因为线程结束后也可以自动释放相关的ThreadLocal变量。

ThreadLocal的方法

1. void set(Object value)设置当前线程的线程局部变量的值。
2. public Object get()该方法返回当前线程所对应的线程局部变量。
3. public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。
4. protected Object initialValue()返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

笔试题

1. 如何解决多线程之间线程安全问题?
   使用多线程之间同步synchronized或使用锁(lock)。
2. 为什么使用线程同步或使用锁能解决线程安全问题呢？
   将可能会发生数据冲突问题(线程不安全问题)，只能让当前一个线程进行执行。代码执行完成后释放锁，让后才能让其他线程进行执行。这样的话就可以解决线程不安全问题。
3. 什么是多线程之间同步？
   当多个线程共享同一个资源,不会受到其他线程的干扰。
4. 同步函数使用的是什么锁？
   同步函数使用this锁，一个线程使用同步代码块(this明锁),另一个线程使用同步函数。如果两个线程抢票不能实现同步，那么会出现数据错误。
5. java内存模型和java内存结构？
   java内存模型是多线程可见性(简称JMM)，JMM决定一个线程对共享变量的写入时,能对另一个线程可见。
   java内存结构属于jvm中的内存分配。
6. volatile与synchronized区别？
   ①volatile轻量级，只能修饰变量。synchronized重量级，还可修饰方法。
   ②volatile只能保证数据的可见性，不能用来同步，因为多个线程并发访问volatile修饰的变量不会阻塞。
   synchronized不仅保证可见性，而且还保证原子性，因为，只有获得了锁的线程才能进入临界区，从而保证临界区中的所有语句都全部执行。多个线程争抢synchronized锁对象时，会出现阻塞。