一、线程安全
    线程安全问题：比如分别在火车站买票，两个窗口卖出了同一张票
    线程存在不安全问题的条件：
    1、多线程并发
    2、有共享数据
    3、共享数据有修改的行为

    异步编程模型：线程A和线程B，各自执行，A不管B，B不管A，其实就是多线程并发
    同步编程模型：线程A和线程B，A需要等待B执行结束后才执行。

    案例模拟取款的过程，设置账户余额为10000，用两个线程分别代表柜台和ATM，同时取款5000，出现线程不安全现象：
    image.png
    使用synchronized 后，线程安全：
    image.png
    如何解决线程安全问题,加锁：synchronized 线程同步锁
    synchronized三种用法：
    1、synchronized (){}
    这样的写法称为同步代码块
     作用：在多线程场景下，可以让每个线程同步执行
    假设有t1，t2线程，t1线程先进入代码块，则t2必须等待，直到t1执行完毕
     同步代码块参数：传递的一个是共享对象（只要是线程共享的都可以，成员变量）
    若定义一个成员变量obj，private Object obj = new Object();也是可以将之作为参数传入同步代码块的，因为成员变量是存储在堆中，也是共享资源。
     局部变量则不行，因为局部变量在栈中。
    这个锁为对象锁，与synchronized (this)一样，是锁定实例化的对象，每个对象有其独立的对象锁，互不干扰。
    当多个并发线程访问同一个对象中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
    当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。
    当一个线程访问对象的一个synchronized(this)同步代码块时，其他线程对对象中所有其它synchronized(this)同步代码块的访问将被阻塞。

    synchronized (){}写法

    1. public void getMoney(double money) {
    3.         synchronized (obj){
    4.             double blance = this.getBlance();
    6.             try {
    7.                 //模拟网络延迟
    8.                 Thread.sleep(1000);
    10.             } catch (InterruptedException e) {
    12.                 e.printStackTrace();
    14.             }
    16.             this.setBlance(blance - money);
    18.             System.out.println(Thread.currentThread().getName()+"取款"+money+"成功,当前账户余额为"+this.getBlance());
    19.         }
    20.     }

    2、synchronized 修饰实例方法（普通方法）
    修饰实例方法时和synchronized (){}作用是一样的，只是作用范围不同，后者效率更高，前者锁住的是这整个方法（也是this，即对象），线程进入后需要将方法内所有内容执行后才释放。

    2. public synchronized void getMoney(double money) {
    4.             double blance = this.getBlance();
    6.             try {
    7.                 //模拟网络延迟
    8.                 Thread.sleep(1000);
    10.             } catch (InterruptedException e) {
    12.                 e.printStackTrace();
    14.             }
    16.             this.setBlance(blance - money);
    18.             System.out.println(Thread.currentThread().getName()+"取款"+money+"成功,当前账户余额为"+this.getBlance());
    19.     }

    3、synchronized修饰静态方法，获取的是类锁（即Class本身），作用范围是整个静态方法，作用的对象是这个类的所有对象，和synchronized(class)类似。

    1. package com.jy.Thread;
    3. public class ThreadDemo05 {
    5.     public static void main(String[] args) {
    7.         CreateThread02 createThread = new CreateThread02();
    9.         Thread t1 = new Thread(createThread);
    10.         t1.setName("t1");
    12.         Thread t2 = new Thread(createThread);
    13.         t2.setName("t2");
    15.         t1.start();
    16.         t2.start();
    17.     }
    18. }
    19. class CreateThread02 implements Runnable{
    20.         @Override
    21.         public void run() {
    22.             CreateThread02.Method02();
    23.         }
    25.     /**
    26.      * 这个是类级别的锁,此时的对象属于CreateThread02类，所以能用
    27.      */
    28.     public synchronized static void Method02(){
    29.         System.out.println("02方法执行开始");
    30.         try {
    31.             Thread.sleep(1000);
    33.         } catch (InterruptedException e) {
    35.             e.printStackTrace();
    36.         }
    37.         System.out.println("02方法执行结束");
    38.     }
    39. }

    二、线程的其他方法
    join（）当前线程进入阻塞,指定线程执行，直到指定线程结束当前线程才可以继续。
    下面代码中join方法是在主线程中被调用的，所以主线程就是当前线程，即被阻塞。
    t.join()方法只会使主线程进入等待池并等待t线程执行完毕后才会被唤醒。并不影响同一时刻处在运行状态的其他线程。·

    1. package com.jy.Thread;
    3. /**
    4.  * join（）合并线程的方法
    5.  */
    6. public class ThreadDemo06 {
    7.     public static void main(String[] args) {
    9.         Thread thread = new Thread(new CreateThread03());
    11.         thread.setName("t1");
    13.         thread.start();
    15.         try {
    16.             thread.join();
    18.         } catch (InterruptedException e) {
    20.             e.printStackTrace();
    21.         }
    23.         for (int i=0;i<100;i++){
    24.             System.out.println(Thread.currentThread().getName()+" "+i);
    26.             try {
    27.                 Thread.sleep(500);
    28.             } catch (InterruptedException e) {
    29.                 e.printStackTrace();
    30.             }
    31.         }
    33.     }
    34. }
    36. class CreateThread03 implements Runnable{
    37.     @Override
    38.     public void run() {
    40.         for (int i=0;i<100;i++){
    41.             System.out.println(Thread.currentThread().getName()+" "+i);
    43.             try {
    45.                 Thread.sleep(500);
    47.             } catch (InterruptedException e) {
    49.                 e.printStackTrace();
    50.             }
    51.         }
    52.     }
    53. }

    线程自己把自己挂起，现用wait(xxx)方法，配合notify()方法使用
    suspend()无法保证资源是释放的，已废弃，但配合resume()用不报错.

    线程自己把自己唤醒，现用notify()方法，配合wait(xxx)方法使用。
    resume()方法调用之后线程不会释放资源的，可能会导致死锁等问题，已废弃，但配合suspend()用不报错.

    stop()：结束线程的时候，无法保证资源是释放的，已经被废弃

    现在使用interrupt()中断线程，并不是强行关闭，而是打个招呼，是否中断由线程自己决定，中断标志位=true。
    interrupt方法也可以用来中断睡眠，把睡眠的线程启动异常处理机制,达到中断的效果。

    t1.isAlive() 判断指定线程是否处于活动状态

    volatile 可以实现多个线程之间的可见性，即属性共享，线程安全，没有原子性，synchronized有，这是volatile 与synchronized的不同。