多线程

      多线程
1、多线程
       在一个应用程序中，有多条路径在同时执行
       作用：实现不同功能的同时执行，相同功能的同时执行，也就是说，开启多个线程就是为了同时运行多部分代码
2、进程：process，每个独立运行的应用程序
      线程：Thread，程序内部的一条执行路径（就是进程中一个负责程序执行的控制单元(执行路径)），jvm允许应用程序并发的运行多个执行路径
      多进程：在操作系统中同时运行多个任务（程序）
      多线程：在同一个应用程序中多条执行路径同时执行
      关系：
      一个进程中至少要有一个线程
3、线程的创建：
      a、继承java.lang.Thread类，重写run方法
             好处：编写简单，可以直接操作线程
             弊端：在继承Thread的类的同时就把Thread类中的方法都继承过来了
      b、实现java.lang.Runnable接口，重写run方法
            *****它的出现仅仅是将线程的任务进行了对象的封装
            好处：1、将线程的任务从线程的子类中分离出来，进行了单独的封装
                                按照面向对象的思想将任务封装成对象
                  2、避免了java单继承的局限性
   当一个类已经有一个爹的时候就不能使用继承Thread类的方式来创建多线程了
            通过实现接口的方式来创建线程对象，并将Runnable接口的子类对象作为Thread类的构            造函数的参数进行传递，这是为什么呢？
            因为线程的任务都封装在runnable接口的子类对象的run方法中，所以要在线程对象创建            时就要明确要运行的任务
      c、匿名内部类
 线程的启动，并不是直接调用run方法，而是调用start方法启动线程，之后，执行run方法
 线程的异常：每个线程中发生的异常是线程自己的事，不会影响其他线程的执行
 4、线程的方法
       start();注意：多次开启一个线程是非法的
    a、sleep(毫秒数)；线程休眠的毫秒数(在哪一个线程调用，哪一个线程休眠)
    b、Tread.currentThread：获得当前正在执行的线程
    c、join( );线程加入或线程合并，等待加入的线程执行结束，在执行其他线程
    d、yield( ):线程让步，暂停当前正在执行的线程，执行其他线程(暂时释放执行权，使线程执行       的和谐)
    e、线程优先级：可以通过setPriority和getPriority方法设置(线程执行到的几率(范围是1-10,越大优先级越高))
                                   并不是哪个线程的优先级高，他就先执行，而是：优先级高的，获得cpu的时间片多；优先级低的，获得cpu的时间片少
5、线程停止
      a、stop( ),已过时，会强行停止正在运行的线程，造成不可预期的效果，不建议使用
       b、interrupt( ),中断线程，并不是停止，表示线程中断过，给线程加一个中断的标记
             interrupted( ),表示线程的中断状态，true表示中断过，false表示没有中断过
       c、设置退出标记，退出线程
6、守护线程，后台驻留的线程，后台线程（当前台线程都结束的时候后台线程随着结束）
       用户线程，前台线程
       区别主要在于虚拟机的离开，如果用户线程已经全部退出执行，此时只剩下守护线程，虚拟机也就退出了，因为此时已经没有了被守护者，对于守护线程已经无工作可做，没有存在的必要，退出执行
 7、线程的状态转换
       创建：实例化线程类对象
       就绪：线程类对象调用start方法，并不是立即进入运行状态，而是进入就绪状态，等待cpu调             度，获得cpu的时间片
       阻塞：线程在运行的过程中，出现阻塞事件，进入阻塞状态，当阻塞状态解除，进入就绪状态
                   sleep：休眠----》睡醒了，休眠时间结束
  join：线程加入------》加入的线程执行结束
  wait：等待---------》notify，notifyAll，唤醒
      终止：线程执行结束
      cpu的执行资格：可以被cpu处理，在处理队列中排队
      cpu的执行权：正在被cpu处理的
      运行时：既具备执行权，又具备执行资格
      冻结状态时：在释放执行权的同时释放执行资格
      临时阻塞状态：具备着执行资格，但是不具备执行权，正在等待着执行权
      
      wait和sleep的区别？
     1、wait可以指定时间也可以不指定
        sleep必须指定时间
     2、在同步中，对cpu的执行权和锁的处理不同
        wait释放执行权，释放锁
        sleep释放执行权，不释放锁


练习：Fibonacci数列，每个线程生成数列一个数字,生成数列中的第几个，由构 造方法指定
提示：递归算法  1,1,2,3,5,8,13
====================================================================================
线程安全问题产生的原因：
1、多个线程在操作共享的数据
2、操作共享数据的代码有多行


同步就解决了这个问题
同步的好处：解决了多线程的安全问题
同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁
同步的前提：必须有多个线程并发使用同一个锁
synchronized（mutex）{//mutex互斥体，就是一个对象
 
}这个对象就是锁，锁用来监视线程的，（因为要后期对同步中的线程进行监视，因为监视的方法都在锁上呢）
当一个线程持有一个mutex时，如果其他线程申请访问同一个mutex时将阻塞，申请不到，此时，可以使用mutex来保证资源的互斥访问，也就是说，对同一资源只能有一个线程访问
mutex：引用类型，锁定this，代表锁定当前对象
同步方法也锁定对象，锁定this


验证静态同步函数的锁：该函数所属字节码文件对象，也就是类所对应的class例如Sale.class
字节码文件进内存先创建对象，字节码文件对象
获取字节码文件对象的两种方式：this.getClass（对象。getClass）    类名.class
     原因：静态方法随着类的加载而加载，此时线程类对象还不存在，不可能是this，但是内存中存在类所对应的class，是class类型的


多线程下的单例：面试题
懒汉式：延迟加载
class Single{
private static Single s = null;
private Single(){ }
}
public static Single getInstance(){
    if(s==null){
      Synchronized(Single.class){
    if(s==null){
      s= new Single();
      return s;
    }
  }
 }
}




2、死锁：多个线程互相等待对方持有的资源
     多线程面试题：请写一个死锁
3、生产者消费者问题
   线程协作，线程交互
4、wait，notifyAll,notify必须使用在同步中，因为同步有锁，通过锁指明持有锁的线程去等待或者唤醒
   wait：让线程进入等待状态，线程被放入线程池，释放锁
   notify：唤醒等待的线程，唤醒线程池中的一个线程
   notifyAll：唤醒线程池中所有线程
为什么三个方法在Object类中？
因为三个方法必须使用在同步中，而线程同步中有锁，锁定的是任意对象，任意对象可以调用 的方法，只能放在object类中
   
5、判断箱子是否转满，箱子是否为空，使用while，不能使用if
   因为：被唤醒的线程应该先去判断（转满或者为空），如果使用if，不会判断，直接向下执行，出现问题，所以使用while，让唤醒的线程先去判断，之后再运行其他代码


6、JDK1.5以后将同步和锁进行了对象的封装
   并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了显示动作
   允许重入的互斥锁 java.util.concurrent.locks
    Lock lock =new ReentrantLock()；
    lock.lock();//获取锁
    try{ 
     code... //需要同步的代码 
    }finally{
    lock.unlock;//释放锁
    }
    将同步替换成lock之后，还报异常：   因为wait，notify，notifyAll只能使用在同步中，但是    现在已经没有同步机制，所以报错。
    jdk提供了Condition接口，对三个方法分解成不同方法，await，signal，signalAll
    Condition对象的创建：
    Lock lock = new ReentrantLock();
    Condition proCon = lock.newCondition();
    Condition conCon = lock.newCondition();
7、ThreadLocal：会误认为线程本地变量，并不是代表当前线程
   底层实现：Map<当前线程，Value> 
   Synchronized和ThreadLocal都可以解决多线程并发引起的数据不安全问题
   Synchronized:用于线程间的数据共享
   ThreadLocal:用于线程间的数据隔离
   // Map<t0,p1>,Map<t1,p2>
ThreadLocal<Person> local = new ThreadLocal<Person>();
// 从ThreadLocal中获得人
public Person getPerson() {
// ThreadLocal底层由Map实现，get（）是根据key获得Value
Person p = local.get();
// 如果第一次使用ThreadLocal，没有存储任何键值对，此时，p为null
// 如果p为null，实例化Person对象，存储到ThreadLocal
// 返回Person对象
if (p == null) {
p = new Person();
local.set(p);
}