多线程和反射

1.Java的反射机制：通过已经装载到JVM中的Java对象（该Java对象已经装载且正在运行中），实现访问、检测和修改描述Java对象本身信息的功能。这些信息包括：构造方法、方法、成员变量等。例如可以得到方法的返回类型，方法的参数个数和类型，或者更改对象中的成员变量值等等。
  ex:
       BJTU  bjtu=new BJTU();        //Java区分大小写，bjtu为BJTU的实例（将一个类实例化，获得对象）
       Class bjtuC=bjtu.getClass();  //object类中定义的getClass()方法，返回一个类型为Class的对象bjtuC,利用bjtuC对象可以访问bjtu对象本身信息，实现反射机制。
       Constructor[] declaredConstructors=bjtuC.getDeclaredConstructors();//通过bjtuC对象获得bjtu对象对应类的所有构造方法，以数组形式存储。 
       Field[] declareFields=bjtuC.getDeclaredFields();//获得对象所有的成员变量


       for(int i=0;i<declaredFields.length;i++)
       {
            Field field=declaredFields[i];
            if(fieldType.equals(int.class))//如果该成员变量的类型为int型
            {
                  field.setInt(bjtu,520); //将该成员变量的值更改为520，实现逆向控制程序的执行过程(比如让程序中的变量再次初始化)
            }


            //以下是Annotation的例子
            if(field.isAnnotationPresent(Schools_Annotation.class))  //如果该字段的注释类型是Schools_Annotation
            {
                Schools_Annotation  sa=field.getAnnotation(Schools_Annotation.class); //获得该字段对应的Schools_Annotation实例sa
                System.out.println("学院是："+sa.describe());        //获得注释中describe参数对应的值
                System.out.println("数据类型是:"+sa.type());
            }
       }


  注：构造方法不一定是public型的，也可以说private/protected型。


2.Annotation(注释)：该功能用于对类、构造方法、成员变量、方法、参数等进行注释，在程序运行时通过反射可以读取这些信息，根据读取的注释信息发现执行逆向控制程序。（比如判断注释类型是否为Schools_Annotation，若是则执行某种操作）
  ex:
     //定义一个Annotation类型
     import java.lang.annotation.*; 
     @Target({ElementType.FIELD,ElementType.METHOD})//@Target说明该Annotation类型适用于成员变量以及成员方法
     @Retention(RetentionPolicy.RUNTIME)            //@Retention设置Annotation的有效范围，此处范围为RUNTIME(运行时)，则在程序运行过程时可以通过反射获得相关的Annotation信息
      public @interface Schools_Annotation{         //定义反射的关键字@interface
          String describe();                        //定义一个没有默认值的String型成员
          Class type() default void.class;          //定义一个默认值为void的Class型成员。
      }


     //在类中使用Annotation注释
     public class BJTU{
       @xueyuan_annotation(describe="运输学院",type=String.class) //注释jtys字段
        String jtys;
     }
    
     //在程序运行时使用反射访问Annotation，见1的例子




3.多线程。进程是一个正在进行的程序。如果一个进程同时完成多段代码的操作，就需要产生多线程。一个进程可以具有多个并发执行的线程。多线程看起来像同时执行，但事实上在同一时间点上只有一个线程被执行，只是线程之间切换较快，给人感觉像在同时进行。（uTorrent本身是一个进程，有的种子在下载，有的种子在上传，这就是一个多线程的例子）
  i.多线程的实现有两种方式。<1.继承java.lang.Thread类。 <2.实现java.lang.Runnable接口。 （实质上，Thread类就是实现了Runnable接口）
   ex1.
       public class ThreadTest extends Thread{    //继承Thread类。
           public void run(){ while(true){...} }  //重写Thread类中的run方法，完成线程真正功能的代码放在类的run方法中。
           public static void main(String[] args)
           {
                 new ThreadTest().start();        //Thread类中的start方法执行线程，也即调用run()方法。在主方法没有调用start()方法前，Thread对象只是一个实例，而不是一个真正的线程     
            }
       }
   ex2.
       public class ThreadTest{
            public static void main(String[] args)
            {
                   private static Thread t=new Thread(new Runnable(){     //定义匿名内部类（该类无名字），该类实现Runnable接口。Thread()的参数是实现了Runnable接口的类的实例
                        public void run(){
                           while(true){
                                ...                                       //JDK已经废除用stop()方法停止线程运行的方式。
                                if(isContinued) break;                    //提倡在run方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。以此来停止线程。
                            }
                        }
                   });                                                    //封号别忘了。
                   t.start();
            }
       }
  ii.线程的生命周期。线程有7种状态：出生、就绪、运行、等待、休眠、阻塞、死亡。
     start()方法前线程都处于出生状态，调用start方法后处于就绪状态，得到系统资源后进入运行状态。当线程在运行状态下发出I/O请求，该线程进入阻塞状态，I/O结束线程进入就绪状态。
     等待wait()和休眠sleep()的区别在于：调用sleep()方法的线程不释放同步锁（资源），调用wait()方法的线程释放锁。
     wait(time)和sleep(time)表示在一定时间内暂停；wait()方法却会使线程永久无限等待下去，需要使用notify()或者notifyAll()方法唤醒。
     run方法执行完，则线程进入死亡状态。
  iii.线程的操作方法。
     <1.线程的休眠。sleep();
       ex.
           ThreadTest t=new ThreadTest();
           try{                                                            //sleep()方法放在try/catch块中，避免抛出InterruptedException异常
                t.sleep(1000);                                             //休眠1000毫秒，即1秒
              }catch(InterruptedException e){}                
     <2.线程的加入。join()方法使当前运行线程暂停，直到调用join()方法的线程执行完毕后再执行。
       ex.
           Thread threadA=new Thread(new Runnable(){
                public void run(){
                      while(true)
                      {
                         try{
                           threadA.sleep(100);
                           threadB.join();                                 //在threadA运行过程中加入threadB,则先执行threadB，threadB执行完后再接着执行threadA。
                         }catch(InterruptedException e){}
                      }
                }
           });
           threadA.start();
           threadA.interrupt();                                            //使用Thead类的interrupt()方法使线程离开run()方法，同时结束线程，但同时抛出InterruptedException。
      <3.线程的中断。使用Thread类的interrupt()方法。
      <4.线程的礼让。Thread类的yield()方法，告诉当前运行中的线程可以将资源礼让给其他线程，但仅是一个暗示，没有任何一种机制保证当前进程会将资源礼让。
      <5.线程的setPriority()方法调整线程的优先级。优先级在1-10之间。 ex.setPriority("threadTest",5,thradA);// 将threadA的线程起名为"threadTest",设置优先级为5。
      <6.线程同步。线程安全问题来源于两个线程同时存取单一对象的数据，造成混乱。解决方法是使用同步块或者同步方法。
         ex1.
            while(true){
                 synchronized(Object)     //用synchronized关键字建立同步块(临界区)，Object为任意对象，每个对象都有一个标志位，标志位为0表示此同步块中已经存在其他线程在运行。
                {                         //当Object标志位被置为1时，其它线程才能执行同步块中的代码。
                    ...//
                }
            }
         ex2.
            public synchronized void doit(){}
            ...
            public run(){
                while(true){
                    doit();              //在run方法中调用同步方法，效果和同步块一样。
                }
            }
4.异常处理。
   i.自定义异常。
    ex.
       public class myException extends Exception{       //自定义异常类myException，继承Exception。
            public myException(String ErrorMessage){     //带参构造方法
                   super(ErrorMessage);                  //调用父类带参构造方法
            }
       }
       public class Test{
            static int avg(int number1,int number2) throws myException   //在方法中抛出myException异常。抛出异常的意思是：发生异常时不处理，抛给上一级处理(在catch块中处理)。
            {
                 if(number1<0 || number2<0)
                 {
                      throw new myException("不能使用负数啊亲！");       //抛出自定义的异常类的实例。
                 }
            }
            public static void main(String[] args)
            {
                 try{
                      int resutl=avg(-2,120);
                      System.out.println(result);
                 }catch(MyException e){
                      System.out.println(e);                             //输出异常信息
                    //e.getMessage();                                    //同上一句，用于返回异常信息。getMessage()是Exception类的方法，子类myException直接继承父类的方法。
                    //e.printStackTrace();                               //输出异常信息。
                 }
            }
       }
   ii.可以使用多个catch语句来捕捉异常，此时需要注意catch语句的顺序。
   iii.Java类库中的每个包中都定义了异常类，所有这些类都是Throwable类的子类。Throwable类有两个子类，即Exception和Error类。
       Error类及其子类用于描述Java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重。
       Exception类称为非致命类，可以通过捕捉异常处理使程序继续执行，即虽然出错，但是只要在try-catch里面，这个错误就可以被"搁置",而不会使整个程序被迫停止。
       Exception类又根据错误发生的原因分为RuntimeException异常和RuntimeException之外的异常。
       常见的RuntimeException有：ArrayIndexOutOfBoundsException(数组下标越界异常)/ArithmeticException(算术异常)/ClassCastException(类型转换异常)/NullPointerException(空指针异常）
       
  注1：在try-catch-finally中，finally块总会被执行，除非以下4种情况：<1.在finally语句块中发生了异常。<2.在前面的代码中用了System.exit()退出程序。<3.程序所在的线程死亡。<4.关闭cpu。
  注2：一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。