12.线程

多线程的创建：
   方式一：继承于thread类
  　　　　 1.创建一个继承于Thread类的子类
  　　　　 2.重写Thread中run() ---将此线程执行的操作声明在run()方法体中
  　　　　 3.创建Thread类的子类对象
  　　　　 4.通过此对象调用start()

   start作用：
  　　　　 ①启动多线程
  　　　　 ② 调用当前线程的run()
   注意：①：不能通过直接调用run()的方式启动线程
        ② 当再启动一个线程，不可以还让已经start()的线程去执行，会报illegalThreadStateException
           需要新建一个线程对象

    测试Thread常用方法
    　　1.start：启动当前线程；调用当前线程run()
    　　2.run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
   　　 3.currentThread：静态方法(类名.方法可调用)；返回执行当前代码的线程
   　　 4.getName()：获取当前线程的名字
   　　 5.setName(): 设置当前线程的名字
   　　 6.yield():释放当前cpu的执行权
   　　 7.jion():在线程A中调用线程B的join()，此时线程A就进入阻塞状态，直到线程B完全执行完以后，线程A才结束阻塞状态。
    　　9.sleep(long millitime):让当前线程“睡眠”指定millitime毫秒，在指定的millitime毫秒时间内，当前线程是阻塞状态
    　　10.isAlive():判断线程是否存活

    线程的优先级
    　　　　1.MAX_PRIORITY:10
     　　　　 MIN_PRIORITY:1
     　　　　 NORM_PRIORITY:5  默认优先级
   　　　　 2.如何获取和设置当前线程的优先级
    　　 　　　　 getPriority();
      　　　　　　setPriority(int p);

      说明：高优先级的线程要抢占低优先级线程CPU的执行权，但只是从概率上讲，高优先级的线程高概率的情况下被执行，
      　　　　并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行

 方式二：实现Runnable接口
  　　　　1.创建一个实现Runnable接口的类
  　　　　2.实现类去实现Runnable中抽象方法run()；
 　　　　 3.创建实现类的对象，
 　　　　 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 　　　　 5.通过Thread类的对象调用start()

  比较创建线程的两种方式：
  　　　　开发中，有限选择，实现Runnable接口的方式
  　　　　原因：　　1.实现的方式没有类的单继承性的局限性
        　　　　　　2.实现的方式更适合来处理多个线程有共享数据的情况
 　　　　 联系：Thread也实现了Runnable接口

  Java中，通过同步机制，来解决线程安全问题
  方式一：同步代码块
  　　　　synchronized(同步监视器){
    　　　　　　 //需要同步的代码

  　　　　}
 　　　　 说明：1.操作共享数据的代码，即为需要同步的代码
       　　　　2.共享数据：多个线程共同操作的变量数据
      　　　　 3.同步监视器，俗称：锁 。任何一个类的对象，都可以充当一个锁
       　　　　  要求：多个线程必须共用同一把锁

  方式二：同步方法
       如果操作共享数据的代码完整的声明在一个方法中，将此方法声明同步的
       实现Runnable的类型 直接在方法中加入关键字synchronized
       继承Thread的类型 需要将方法变成static 并且加上关键字synchronized

       说明：1.同步方法仍然涉及同步监视器，只是不需要显示声明
            2.非静态的同步方法，同步监视器是：this
            3.对于静态同步方法，同步监视器是：当前类本身

  说明：
  　　同步好处：同步的方式，解决了线程的安全问题
  　　局限性：操作同步代码时，只能有一个线程参与，其他线程等待。相当于是单线程的过程，效率低

  死锁问题
 　　 1.死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了死锁
 　　 2.说明：
   　　　　1）出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
   　　　　2)使用同步时，需要避免出现死锁


 解决线程安全方式三：lock锁
  1.在实现类或者子类中，创建ReentrantLock对象
  2.将对共享资源用try-finally包装，try中调用锁定方法lock(),finally中调用解锁方法unlock();

synchronized 和 lock 方法解决线程安全问题的异同

同：二者解决线程安全问题
异：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
    Lock需要手动启动同步（lock()）,同时结束同步也需要手动实现（unlock()）

线程通信的三个方法：
  wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
  notify()：一旦执行此方法，就会唤醒被wait的一个阻塞线程，如果有多个线程被wait，就唤醒优先级高的那个
  notifyAll()：一旦执行此方法，就会唤醒被wait的所有阻塞线程。

  说明：
   1.wait()、notify()、notifyAll() 必须使用在同步代码块或同步方法中
   2.wait()、notify()、notifyAll() 三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现IllegalMonitorStateException
   3.wait()、notify()、notifyAll()三个方法是定义在java.lang.Object类中

 线程的创建方式三：实现Callable接口
     可以有返回值、方法可以抛出异常、支持泛型的返回值、需要借助FutureTask类
   1.创建一个实现Calllable的实现类
     class NumThread implements Callable
   2.实现call方法，将此线程需要执行的操作声明在call()中
     public Object call() throws Exception
   3.创建Callable接口实现类的对象
     NumThread n1 = new NumThread()
   4.将此Callable接口实现类的对象作为参数，传递到FutureTask构造器中，创建FutureTask的对象
     FutureTask f1 = new FutureTask(n1);
   5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread的对象，并start()调用
     new Thread(f1).start();

 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大
 1.call()可以有返回值，
 2.call()可以抛出异常，被外面操作捕获，获取异常的信息
 3.Callable可以支持泛型的

 线程的创建方式四：使用线程池
 1.提供指定线程数量的线程池
   ExecutorService service = Executors.newFixedThreadPool(10);
 2.执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
    service.execute(new NumberThread());//适合于Runnable
    service.submit();//适合于Callable

使用线程池的好处
1.提高响应速度（减少了创建新线程的时间）
2.降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
3.便于线程管理
    corePoolSize 核心池的大小
    maximumPoolSize：最大线程数
    keepAliveTime：线程没有任务时最多保持多长时间后会终止