Java基础知识(十二)

十六反射

16.2.1 反射的概念

反射是在运行时获取类或对象的信息的能力。具体的讲：可以通过类名或对象获取该类的相关信息，例如类的属性和方法、类实现接口或继承父类。甚至可以通过反射在运行过程中实例化对象，动态调用方法。

反射是在运行过程中进行检索/检查自身的一个机制。

反射是通过Class、Constructor、Field以及Method类实现的。这些类位java.lang.reflect包下。

16.2.2 类加载与Class对象

在程序中使用某个类时，JVM首先需要将该类的class文件加载到内存，并为之创建一个java.lang.Class类型的对象。这个对象就是所谓的Class对象，通过该对象就可以获取该类的相关信息。

可以通过以下三种方式获取类的Class对象：

l 类名.class //大部分时候使用这种方式

l 对象.getClass()

l Class.forName(“类的全名”) //参数必须是类的全名

一旦获得了类的Class对象，就可以通过该Class对象获取类的相关信息了。

16.2.3 获取类的相关信息

通过类的Class对象，可以获取类的属性、方法、构造方法等信息，这些信息分别用Field、Method、Constructor类型的对象表示。

获取Student类中所有的属性、方法、构造方法：

Field[] fields = Student.class.getDeclaredFields(); //getFields() 字段

Method[] methods = c1.getDeclaredMethods(); //getMethods() 方法

Constructor[] cs = c1.getDeclaredConstructors(); //getConstructor()构造方法

获取Student类中公有的属性、方法、构造方法：

Field[] fields = Student.class.getFields();

Method[] methods = c1.getMethods();

Constructor[] cs = c1.getConstructors();

此外还可以获取指定的属性、方法、构造器。

16.1.4 使用反射生成并操作对象

获得了类的Class对象后，还可以通过Class对象调用newInstance()方法创建该类的对象。

Class<Student> c1 = Class.forName(“www.xszx.com”);

Student s = c1.newInstance(); //这种情况要求Student类提供了无参构造方法

创建对象的另外一种方法：通过Constructor对象。

一、继承Thread，重写run方法

通过自定义一个类（这里起名为：MyThread），继承Thread类，重写run方法，最后在main方法中new出MyThread实例，调用这个实例的继承的Thread类的start方法创建一个线程。

Ps：

1.创建出MyThread实例，并不代表在系统真的创建一个线程，只有调用start方法时，才创建出一个新的线程，新线程会执行run里的逻辑，直到run里逻辑执行完，线程就结束了；

2.运行一次Java程序就启动了一个进程，一个进程里至少会有一个线程，这里JVM默认创建的线程就是main线程（主线程），main主线程和MyThread创建出来的新线程是“并发执行”的关系（并发+并行），也可以理解为同时执行，各执行各的；

3.直接调用run并没有创建线程，只是在原来的线程中执行代码；

代码如下：

class MyThread extends Thread {

@Override

public void run() {

System.out.println("继承Thread，重写run方法创建线程");

}

}

public class Main {

public static void main(String[] args) {

MyThread myThread = new MyThread();

myThread.start();

}

}

二、实现Runnable接口，重写run方法

通过自定义一个类（这里起名为：MyRunnable）实现Runnable接口，重写run方法，最后在main方法new出MyRunnable实例和Thread实例，最后通过start方法创建并启动线程。

通俗理解：

这里相当于把线程要干的活和线程本身分离开了，使用MyRunnable这个自定义的类来表示“线程要完成的任务”，这样做的目的就是为了“解耦合”，假设未来有新的任务需要线程去执行，那么通过这种方式，代码改动就比较小。

代码如下：

class MyRunnable implements Runnable {

@Override

public void run() {

System.out.println("实现Runnable接口，重写run方法");

}

}

public class Main {

public static void main(String[] args) {

MyRunnable myRunnable = new MyRunnable();

Thread thread = new Thread(myRunnable);

thread.start();

}

}

三、使用匿名内部类创建 Thread 子类对象

直接创建Thread子类，同时实例化出一个对象，重写run方法，最后通过start方法创建并启动线程。

代码如下：

public class Main {

public static void main(String[] args) {

Thread thread = new Thread() {

@Override

public void run() {

System.out.println("使用匿名内部类创建 Thread 子类对象");

}

};

thread.start();

}

}

四、使用匿名内部类，实现Runnable接口

通过使用使用匿名内部类，实现Runnable接口作为Thread构造方法的参数，最后通过start创建并启动线程；

代码如下：

public class Main {

public static void main(String[] args) {

Thread thread = new Thread(new Runnable() {

@Override

public void run() {

System.out.println("使用匿名内部类，实例Runnable接口作为构造参数");

}

});

thread.start();

}

}

五、lambda表达式

lambda本质上就是一个“匿名函数”，()表示函数的形参，{}表示函数体，->特殊语法，表示它是lambda表达式(->是从C++那里抄来的)。

代码如下：

public class Main {

public static void main(String[] args) {

Thread thread = new Thread( () -> {

System.out.println("使用lambda表示创建线程");

});

thread.start();

}

}

六、实现Callable接口

通过自定义类（这里起名为：MyCallable），实现Callable接口，重写call方法（call方法可以理解为线程需要执行的任务），并且带有返回值，这个返回表示一个计算结果，如果无法计算结果，则引发Exception异常，如下源码英文解释：

接着创建Callable实例，使用FutrueTast类包装Callable对象，FutureTask是一个包装器，需要接收Callable实例来创建，并且有两个构造函数，一个参数只有Callable对象，另一个参数不仅有Callable对象，还有一个泛型的result参数，详细解释如下源码：

最后使用FutureTask对象作为Thread的构造参数，通过start方法创建并启动线程；

注意：这里可以用get方法获取线程执行后的返回值。

代码如下：

class MyCallableTest implements Callable<Integer> {

@Override

public Integer call() throws Exception {

System.out.println("创建线程:" + Thread.currentThread().getName());

return 2;

}

}

public class Main {

public static void main(String[] args) throws ExecutionException, InterruptedException {

FutureTask<Integer> task = new FutureTask<>(new MyCallableTest());

Thread thread = new Thread(task);

thread.start();

System.out.println("创建线程的返回结果为:" + task.get());

}

}

七、使用线程池创建线程

在Java中，线程池的本体叫ThreadPoolExecutor，他的构造方法写起来十分麻烦，为了简化构造方法，标准库就提供了一系列工厂方法，简化使用；

什么是工厂模式？

工厂模式，将创建产品实例的权利移交工厂，我们不再通过new来创建我们所需的对象，而是通过工厂来获取我们需要的产品。降低了产品使用者与使用者之间的耦合关系；

也就是说这里创建线程池没有显式new，而是通过Executors这个静态方法newCaChedThreadPool来完成的；

常见用法：

线程池的单纯使用很简单，使用submit方法，把任务提交到线程池中即可，线程池中会有线程来完成这些任务；

代码如下：

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class Pool {

public static void main(String[] args) {

ExecutorService pool = Executors.newCachedThreadPool();

pool.submit(new Runnable() {

@Override

public void run() {

//执行业务逻辑

for(int i = 1; i <= 100; i++) {

System.out.println("线程:" + Thread.currentThread().getName() + "执行了任务" + i + "~");

}

}

});

pool.submit(new Runnable() {

@Override

public void run() {

//执行业务逻辑

for(int i = 101; i <= 200; i++) {

System.out.println("线程:" + Thread.currentThread().getName() + "执行了任务" + i + "~");

}

}

});

pool.submit(new Runnable() {

@Override

public void run() {

//执行业务逻辑

for(int i = 201; i <= 300; i++) {

System.out.println("线程:" + Thread.currentThread().getName() + "执行了任务" + i + "~");

}

}

});

}

}

当任务量达到一定程度，一个线程忙不过来时，就会发现其他线程也来帮忙辽~

进程与线程

进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。（进程是资源分配的最小单位）

　　线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位）

　　线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。

　　多进程是指操作系统能同时运行多个任务（程序）。

　　多线程是指在同一程序中有多个顺序流在执行。