Java反射机制和线程

JAVA反射机制

已经加载过这个类，通过类名来找到这个类的所有相关信息。

• 在运行时判断任意一个对象所属的类
• 在运行时构造任意一个类的对象
• 在运行时判断任意一个类所具有的成员变量和方法
• 在运行时调用任意一个对象的成员变量和方法
• 生成动态代理

反射相关的主要API:

• java.lang.Class : 代表一个类
• java.lang.reflect.Method : 代表类的方法
• java.lang.reflect.Field : 代表类的成员变量
• java.lang.flect.Constructor : 代表类的构造方法

// 获取Class对象
Class clazz = p.getClass();  // clazz里面包含了对象p所属类的有关信息
Class c1 = Person.class;  //  通过类名.class创建指定类的Class实例
Class c2 = Class.forName("包名.类名");  // 这个比较常用

// 获取
clazz.getName(); // 获取名称
clazz.getModifiers();  // 获取修饰符
Class[] paramClazz = clazz.getParameterTypes();  // 获取参数类型
Class superClazz = clazz.getSuperClass();  // 获取父类
Class[] interfaces = clazz.getInterfaces();  // 获取接口
Constructor[] cons = clazz.getConstructors();  // 获取public构造方法
Constructor[] cons = clazz.getDeclaredConstructors();  // 获取所有构造方法

// 动态调用构造器，创建对象，得到的都是Object，需要强制转换
Object obj = clazz.newInstance(); // 调用无参构造
Constructor con = clazz.getConstructor(String.class);
//获得参数为String的构造器。用DeclaredConstructors()可以获取private的构造方法。但是要在前面加一句，con.setAccessible(true); 解封装
Object obj = con.newInstance("lzq");  // 调用有参构造

// 动态获取方法、属性进行操作. 对私有属性、方法操作是，注意解封装
Method[] ms = clazz.getMethods();  // 获得全部公有方法，要获得私有的和上同理。
Field[] fs = clazz.getFiedls();  // 获取属性
Package p = clazz.getPackage();  //  获取包名
// 得到名称叫name 参数是String String 的方法。
Method m1 = clazz.getMethod("name",String.class,String.class);  
m1.invoke(obj, args);  // 参数1是需要实例化的对象，通过前面的构造可以得到，参数2是可变长的前面方法的实际参数，如果调用的方法有返回值，就接受并强制类型转换。
Field f = clazz.getFiedl("属性名");
f.set(stu, "aaaa");  // 设置stu对象的f属性值为aaaa
f.get(stu);  // 获取stu对象的f属性值，接收时注意类型转换。

// java 动态代理。注意 一个对象想要被代理，一定要有接口。
class ProxyOfTest implements InvocationHandler{
    Object obj;  // 被代理的对象
    public ProxyOfTest(Object obj){
        this.obj = obj;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) 
        throws Throwable{
        // 此处 在指定方法调用前，动态添加行为
        Object result = method.invoke(this.obj, args); //执行的是代理对象的制定方法。
        // 此处 在指定方法调用后，动态添加行为
        return result;
    }
}
InvocationHandler handler = new ProxyOfTest(test); //对test对象进行代理，得到代理对象hander
Test t = (Test)Proxy.newProxyInstance(handler.getClass().getClassLoader(), test.getClass().getInterfaces(), handler);  // 返回的是Object类型，是成功代理后的对象。
t.test(); 

Java线程

Java.lang.Thread类

• run()
• start()

/*创建线程*/
class TestThread extends Thread{ //继承Thread类的方式创建多线程
    @Override
    public void run() {
        //  多线程运行的代码
    }
}
Thread t0 = new TestThread();
t0.start();  // 启动线程，运行run方法，是异步执行


class TestRunnable implements Runnable{ // 实现Runnable接口
    @Override
    public void run() {
        //  多线程运行的代码
    }
}
Thread t1 = new Thread(new TestRunnable());
Thread t2 = new Thread(new TestRunnable(), "t2");// 也可以通过这个方式，第二个参数是线程名称。
t1.start();  

使用Runnable接口实现，避免了单继承的局限性，使得多个线程可以共享一个接口实现对象，处理同一份资源。

一些常用的方法：

String name = t.getName();  // 返回线程的名称 默认为Thread-0，Threa-1等
t.setName("name");  // 设置线程名称 
/*线程优先级:1-10; 数字越大越高，默认为5*/
int t.getPriority();
t.setPriority(int);
Thread.yeild();  // 线程让步：暂停自己的执行，把执行机会让给别的线程
Thread.sleep(1000);  // 当前线程睡眠1000ms。
t.join(); // 相当于把t的run方法插入到这个位置。阻塞了当前的main方法，先执行join进来的线程的代码
t.stop(); // 强制停止
boolean t.isAlive();  // 判断当前线程是否还活着。

线程同步

• 使用同一个同步锁的才能实现线程同步。

• 在public方法上加上关键字 synchronized 同步锁。锁的是某个对象不是仅仅某个方法。不同的对象是不同的同步锁。

• 在static方法上加synchronized 同步锁。所有的实例化对象都是同一个同步锁。

• 用 synchronized(this){ } 来锁某个代码块。如果在其他方法中也有synchronized(this)锁住的代码块，它们使用的是同一个同步锁。

• class A{ 
      public void test(A a) {
          synchronized(a){
              // 这样子可以实现不同对象有不同的锁
          }
      }
  }
  

如果针对对象要加同步锁，那就加在方法上。
如果针对某一段代码需要加同步锁，那就直接在代码块上加同步锁。

线程通信

// a 为临界资源
a.wait(); // 阻塞
a.notify();  // 唤醒
a.notifyAll(); 
// 这三个方法只能用在有同步锁的方法里面

生产者和消费者

public class Test3{
    public static void main(String[] args){
        Clerk c = new Clerk();
        // 生产者
        new Thread(new Runnable(){
            @Override
            public void run(){
                synchronized (c) {
                    while(true){
                        if(c.productNum == 0){
                            // 生产产品
                            c.productNum++;
                            c.notify; // 唤醒消费者
                        }else{
                            c.wait(); // 让生产者等待
                        }
                    }
                }
            }
        },"生产者").start();
        
        // 消费者
        new Thread(new Runnable(){
            @Override
            public void run(){
                synchronized (c) {
                    while(true){
                        if(c.productNum > 0){
                            // 消费产品
                            c.productNum--;
                            c.notify; // 唤醒生产者
                        }else{
                            c.wait(); // 让消费者者等待
                        }
                    }
                }
            }
        },"消费者").start();
    }
}

public class Clerk{
    public static int productNum = 0;
}