四.异常和线程和同步（基础）

异 常：★★★★

　　异常：就是不正常。程序在运行时出现的不正常情况。其实就是程序中出现的问题。这个问题按照面向对象思想进行描述，并封装成了对象。因为问题的产生有产生的原因、有问题的名称、有问题的描述等多个属性信息存在。当出现多属性信息最方便的方式就是将这些信息进行封装。异常就是java按照面向对象的思想将问题进行对象封装。这样就方便于操作问题以及处理问题。

　　出现的问题有很多种，比如角标越界，空指针等都是。就对这些问题进行分类。而且这些问题都有共性内容比如：每一个问题都有名称，同时还有问题描述的信息，问题出现的位置，所以可以不断的向上抽取。形成了异常体系。 java.lang.Throwable。

　　Throwable：可抛出的。 

　　　　|——Error：错误，一般情况下，不编写针对性的代码进行处理，通常是jvm发生的，需要对程序进行修正。

              |——Exception：异常，可以有针对性的处理方式

        无论是错误还是异常，它们都有具体的子类体现每一个问题，它们的子类都有一个共性，就是都以父类名才作为子类的后缀名。这个体系中的所有类和对象都具备一个独有的特点；就是可抛性。

　　可抛性的体现：就是这个体系中的类和对象都可以被throws和throw两个关键字所操作。
　

class  ExceptionDemo{
　　　　public static void main(String[] args) {
　　　　　// byte[] buf = new byte[1024*1024*700];//java.lang.OutOfMemoryError内存溢出错误
　　　　}
　　}


　　//处理方式有两种：1、捕捉；2、抛出。
　　//对于捕捉：java有针对性的语句块进行处理。
　　try {

　　　　需要被检测的代码；
　　}
　　catch(异常类 变量名){
　　　　异常处理代码；
　　}
　　fianlly{

　　    一定会执行的代码；
　　}

——————————————————————————————————————————————————————

　　catch (Exception e) { //e用于接收try检测到的异常对象。
　　　　System.out.println("message:"+e.getMessage());//获取的是异常的信息。
　　　　System.out.println("toString:"+e.toString());//获取的是异常的名字+异常的信息。
　　　　e.printStackTrace();//打印异常在堆栈中信息；异常名称+异常信息+异常的位置。

　　}

　

　　异常处理原则：功能抛出几个异常，功能调用如果进行try处理，需要与之对应的catch处理代码块，这样的处理有针对性，抛几个就处理几个。

　特殊情况：try对应多个catch时，如果有父类的catch语句块，一定要放在下面。

　　throw 和throws关键字的区别：

　　　　throw用于抛出异常对象，后面跟的是异常对象；throw用在函数内。

　　　　throws用于抛出异常类，后面跟的异常类名，可以跟多个，用逗号隔开。throws用在函数上。

　　通常情况：函数内容如果有throw，抛出异常对象，并没有进行处理，那么函数上一定要声明，否则编译失败。但是也有特殊情况。

　　异常分两种：

　　　　1：编译时被检查的异常，只要是Exception及其子类都是编译时被检测的异常。

　　　　2：运行时异常，其中Exception有一个特殊的子类RuntimeException，以及RuntimeException的子类是运行异常，也就说这个异常是编译时不被检查的异常。

　　编译时被检查的异常和运行时异常的区别：

　　　　编译被检查的异常在函数内被抛出，函数必须要声明，否编译失败。

　　　　声明的原因：是需要调用者对该异常进行处理。

　　　　运行时异常如果在函数内被抛出，在函数上不需要声明。

　　　　不声明的原因：不需要调用者处理，运行时异常发生，已经无法再让程序继续运行，所以，不让调用处理的，直接让程序停止，由调用者对代码进行修正。

　　定义异常处理时，什么时候定义try，什么时候定义throws呢？

　　　　功能内部如果出现异常，如果内部可以处理，就用try；

　　　　如果功能内部处理不了，就必须声明出来，让调用者处理。

　　自定义异常：当开发时，项目中出现了java中没有定义过的问题时，这时就需要我们按照java异常建立思想，将项目的中的特有问题也进行对象的封装。这个异常，称为自定义异常。

　　对于除法运算，0作为除数是不可以的。java中对这种问题用ArithmeticException类进行描述。对于这个功能，在我们项目中，除数除了不可以为0外，还不可以为负数。可是负数的部分java并没有针对描述。所以我们就需要自定义这个异常。

自定义异常的步骤：

　　　　1：定义一个子类继承Exception或RuntimeException，让该类具备可抛性。

　　　　2：通过throw 或者throws进行操作。

　　异常的转换思想：当出现的异常是调用者处理不了的，就需要将此异常转换为一个调用者可以处理的异常抛出。

　　这种情况，如果出现异常，并不处理，但是资源一定关闭，所以try  finally集合只为关闭资源。

　　记住：finally很有用，主要用户关闭资源。无论是否发生异常，资源都必须进行关闭。

　　System.exit(0); //退出jvm，只有这种情况finally不执行。

　　当异常出现后，在子父类进行覆盖时，有了一些新的特点：

　　　　1：当子类覆盖父类的方法时，如果父类的方法抛出了异常，那么子类的方法要么不抛出异常要么抛出父类异常或者该异常的子类，不能抛出其他异常。

　　　　2：如果父类抛出了多个异常，那么子类在覆盖时只能抛出父类的异常的子集。

　　注意：

　　　　如果父类或者接口中的方法没有抛出过异常，那么子类是不可以抛出异常的，如果子类的覆盖的方法中出现了异常，只能try不能throws。

　　　　如果这个异常子类无法处理，已经影响了子类方法的具体运算，这时可以在子类方法中，通过throw抛出RuntimeException异常或者其子类，这样，子类的方法上是不需要throws声明的。

　　常见异常：

　　　　1、脚标越界异常（IndexOutOfBoundsException）包括数组、字符串；

　　　　　　空指针异常（NullPointerException）

　　　　2、类型转换异常：ClassCastException

　　　　3、没有这个元素异常：NullPointerException

　　　　4、不支持操作异常；

　

———————————————————————————————————————————

多线程：★★★★

　　进程：正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。

　　线程：其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。一个进程至少有一个线程在运行，当一个进程中出现多个线程时，就称这个应用程序是多线程应用程序，每个线程在栈区中都有自己的执行空间，自己的方法区、自己的变量。

　　jvm在启动的时，首先有一个主线程，负责程序的执行，调用的是main函数。主线程执行的代码都在main方法中。

　　当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。

        随机性的原理：因为cpu的快速切换造成，哪个线程获取到了cpu的执行权，哪个线程就执行。又名抢占式调度

　　返回当前线程的名称：Thread.currentThread().getName()

　　线程的名称是由：Thread—编号定义的。编号从0开始。

　　线程要运行的代码都统一存放在了run方法中。

　　线程要运行必须要通过类中指定的方法开启。start方法。（启动后，就多了一条执行路径）

　　start方法：1）、启动了线程；2）、让jvm调用了run方法。

　　创建线程的第一种方式：继承Thread ，由子类复写run方法。

　　步骤：

　　　　1，定义类继承Thread类；

　　　　2，目的是复写run方法，将要让线程运行的代码都存储到run方法中；

　　　　3，通过创建Thread类的子类对象，创建线程对象；

　　　　4，调用线程的start方法，开启线程，并执行run方法。

　　线程状态：

　　　　被创建：start()

　　　　运行：具备执行资格，同时具备执行权；

　　　　冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；

　　　　临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；

　　　　消亡：stop()

　　创建线程的第二种方式：实现一个接口Runnable。

　　步骤：

　　　　1，定义类实现Runnable接口。

　　　　2，覆盖接口中的run方法（用于封装线程要运行的代码）。

　　　　3，通过Thread类创建线程对象；

　　　　4，将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。

　　　　　　为什么要传递呢？因为要让线程对象明确要运行的run方法所属的对象。

　　　　5，调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。

　　　　　　Ticket t = new Ticket();

　　　　　　/*直接创建Ticket对象，并不是创建线程对象。

　　　　　　因为创建对象只能通过new Thread类，或者new Thread类的子类才可以。

　　　　　　所以最终想要创建线程。既然没有了Thread类的子类，就只能用Thread类。*/

　　　　　　Thread t1 = new Thread(t); //创建线程。

　　　　　　/*只要将t作为Thread类的构造函数的实际参数传入即可完成线程对象和t之间的关联

　　　　　　为什么要将t传给Thread类的构造函数呢？其实就是为了明确线程要运行的代码run方法。*/

　　　　　　t1.start();

　　为什么要有Runnable接口的出现？

　　1：通过继承Thread类的方式，可以完成多线程的建立。但是这种方式有一个局限性，如果一个类已经有了自己的父类，就不可以继承Thread类，因为java单继承的局限性。

　　　　可是该类中的还有部分代码需要被多个线程同时执行。这时怎么办呢？

　　　　只有对该类进行额外的功能扩展，java就提供了一个接口Runnable。这个接口中定义了run方法，其实run方法的定义就是为了存储多线程要运行的代码。

　　　　所以，通常创建线程都用第二种方式。

　　　　因为实现Runnable接口可以避免单继承的局限性。

　　2：其实是将不同类中需要被多线程执行的代码进行抽取。将多线程要运行的代码的位置单独定义到接口中。为其他类进行功能扩展提供了前提。

　　　　所以Thread类在描述线程时，内部定义的run方法，也来自于Runnable接口。

　　　　实现Runnable接口可以避免单继承的局限性。而且，继承Thread，是可以对Thread类中的方法，进行子类复写的。但是不需要做这个复写动作的话，只为定义线程代码存放位置，实现Runnable接口更方便一些。所以Runnable接口将线程要执行的任务封装成了对象。　

//面试

　　　　new Thread(new Runnable(){  //匿名
　　　　　　public void run(){
　　　　　　　　System.out.println("runnable run");
　　　　　　}
　　　　})
　　　　{
　　　　　　public void run(){
　　　　　　　　System.out.println("subthread run");
　　　　　　}
　　　　}.start();  //结果：subthread run

——————————————————————————————————————————————————————

　　　　

　　多线程安全问题的原因：

　　　　通过图解：发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。

　　涉及到两个因素：

　　　　1，多个线程在操作共享数据。

　　　　2，有多条语句对共享数据进行运算。

　　　　　　原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。

　　解决安全问题的原理：

　　　　只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。

　　如何进行多句操作共享数据代码的封装呢？

　　　　java中提供了一个解决方式：就是同步代码块。

　　　　格式：

　　　　synchronized(对象) {  // 任意对象都可以。这个对象就是锁。

　　　　　　需要被同步的代码；

　　　　}

——————————————————————————————————————————————————————

同步：★★★★★

　　好处：解决了线程安全问题。

　　弊端：相对降低性能，因为判断锁需要消耗资源，产生了死锁。

　　定义同步是有前提的：

　　　　1，必须要有两个或者两个以上的线程，才需要同步。

　　　　2，多个线程必须保证使用的是同一个锁。

　　同步的第二种表现形式：

               同步函数：其实就是将同步关键字定义在函数上，让函数具备了同步性。

　　　　同步函数是用的哪个锁呢？

　　　　　　通过验证，函数都有自己所属的对象this，所以同步函数所使用的锁就是this锁。

　　　当同步函数被static修饰时，这时的同步用的是哪个锁呢？

　　　　静态函数在加载时所属于类，这时有可能还没有该类产生的对象，但是该类的字节码文件加载进内存就已经被封装成了对象，这个对象就是该类的字节码文件对象。

　　　　所以静态加载时，只有一个对象存在，那么静态同步函数就使用的这个对象。

　　　　这个对象就是 类名.class

　　同步代码块和同步函数（方法）的区别？

　　　　同步代码块使用的锁可以是任意对象。

　　　　同步函数使用的锁是this，静态同步函数的锁是该类的字节码文件对象。

　　　　在一个类中只有一个同步，可以使用同步函数。如果有多同步，必须使用同步代码块，来确定不同的锁。所以同步代码块相对灵活一些。同步方法相对书写简单一点

——————————————————————————————————————————————————————

　　★考点问题：请写一个延迟加载的单例模式？写懒汉式；当出现多线程访问时怎么解决？加同步，解决安全问题；效率高吗？不高；怎样解决？通过双重判断的形式解决。
　　

//懒汉式：延迟加载方式。

　　当多线程访问懒汉式时，因为懒汉式的方法内对共性数据进行多条语句的操作。所以容易出现线程安全问题。为了解决，加入同步机制，解决安全问题。但是却带来了效率降低。

　　为了效率问题，通过双重判断的形式解决。

　　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;
　　　　}
　　}

——————————————————————————————————————————————————————

　　同步死锁：通常只要将同步进行嵌套，就可以看到现象。同步函数中有同步代码块，同步代码块中还有同步函数。

　　线程间通信：思路：多个线程在操作同一个资源，但是操作的动作却不一样。

　　　　1：将资源封装成对象。

　　　　2：将线程执行的任务(任务其实就是run方法。)也封装成对象。

　　等待唤醒机制：涉及的方法：

　　　　wait:将同步中的线程处于冻结状态。释放了执行权，释放了资格。同时将线程对象存储到线程池中。

　　　　notify：唤醒线程池中某一个等待线程。

　　　　notifyAll:唤醒的是线程池中的所有线程。

　　注意：

　　　　1：这些方法都需要定义在同步中。 

　　　　2：因为这些方法必须要标示所属的锁。

　　　　　　你要知道 A锁上的线程被wait了,那这个线程就相当于处于A锁的线程池中，只能A锁的notify唤醒。

　　　　3：这三个方法都定义在Object类中。为什么操作线程的方法定义在Object类中？

　　　　　　因为这三个方法都需要定义同步内，并标示所属的同步锁，既然被锁调用，而锁又可以是任意对象，

　　　　　　那么能被任意对象调用的方法一定定义在Object类中。

　　wait和sleep区别： 

                分析这两个方法：从执行权和锁上来分析：

　　　　wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。

　　　　sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。

　　　　wait：线程会释放执行权，而且线程会释放锁。

　　　　Sleep：线程会释放执行权，但不是不释放锁。

　　线程的停止：通过stop方法就可以停止线程。但是这个方式过时了。

　　　　停止线程：原理就是：让线程运行的代码结束，也就是结束run方法。

　　　　怎么结束run方法？一般run方法里肯定定义循环。所以只要结束循环即可。

　　　　第一种方式：定义循环的结束标记。

　　　　第二种方式：如果线程处于了冻结状态，是不可能读到标记的，这时就需要通过Thread类中的interrupt方法，将其冻结状态强制清除。让线程恢复具备执行资格的状态，让线程可以读到标记，并结束。

　　—————————< java.lang.Thread >————

　　　　interrupt()：中断线程。

　　　　setPriority(int newPriority)：更改线程的优先级。

　　　　getPriority()：返回线程的优先级。

　　　　toString()：返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

　　　　Thread.yield()：暂停当前正在执行的线程对象，并执行其他线程。

　　　　setDaemon(true)：将该线程标记为守护线程或用户线程。将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，

　　　　　　　　　　　　　Java 虚拟机退出。该方法必须在启动线程前调用。

　　　　join：临时加入一个线程的时候可以使用join方法。

　　　　　　当A线程执行到了B线程的join方式。A线程处于冻结状态，释放了执行权，B开始执行。

　　　　　　A什么时候执行呢？只有当B线程运行结束后，A才从冻结状态恢复运行状态执行。

——————————————————————————————————————————————————————

Lock接口：

多线程在JDK1.5版本升级时，推出一个接口Lock接口。

　　解决线程安全问题使用同步的形式，(同步代码块，要么同步函数)其实最终使用的都是锁机制。

　　到了后期版本，直接将锁封装成了对象。线程进入同步就是具备了锁，执行完，离开同步，就是释放了锁。

　　在后期对锁的分析过程中，发现，获取锁，或者释放锁的动作应该是锁这个事物更清楚。所以将这些动作定义在了锁当中，并把锁定义成对象。

　　所以同步是隐示的锁操作，而Lock对象是显示的锁操作，它的出现就替代了同步。

　　在之前的版本中使用Object类中wait、notify、notifyAll的方式来完成的。那是因为同步中的锁是任意对象，所以操作锁的等待唤醒的方法都定义在Object类中。

　　而现在锁是指定对象Lock。所以查找等待唤醒机制方式需要通过Lock接口来完成。而Lock接口中并没有直接操作等待唤醒的方法，而是将这些方式又单独封装到了一个对象中。这个对象就是Condition，将Object中的三个方法进行单独的封装。并提供了功能一致的方法 await()、signal()、signalAll()体现新版本对象的好处。

< java.util.concurrent.locks > Condition接口：await()、signal()、signalAll()；

——————————————————————————————————————————————————————　　

class BoundedBuffer {
  　　 final Lock lock = new ReentrantLock();
  　　 final Condition notFull  = lock.newCondition(); 
  　　 final Condition notEmpty = lock.newCondition(); 
 　　  final Object[] items = new Object[100];
 　　  int putptr, takeptr, count;

  　　 public void put(Object x) throws InterruptedException {
  　　   lock.lock();
   　　  try {
   　　    while (count == items.length) 
       　　  notFull.await();
      　　 items[putptr] = x; 
     　　  if (++putptr == items.length) putptr = 0;
     　　  ++count;
     　　  notEmpty.signal();
   　　  } 

　　　　finally {
     　　 　　 lock.unlock();
    　　 }
   　　}

   　　public Object take() throws InterruptedException {
    　　　　 lock.lock();
    　　　　 try {
　　　　　　　while (count == 0) 
　　　　　　　notEmpty.await();
　　　　　　　Object x = items[takeptr]; 
　　　　　　　 if (++takeptr == items.length) takeptr = 0;
　　　　　　　——count;
　　　　　　　notFull.signal();
　　　　　　　 return x;
     　　　　} 

　　　　　　finally {
      　　　　　　 lock.unlock();
    　　　　 }
   　　　} 
　　 }