反射、线程

反射

如何在程序运行的情况下去创建另外一个对象？？？

• JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
• 对于任意一个对象，都能够调用它的任意一个方法和属性；
• 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
• 要想解剖一个类,必须先要获取到该类的字节码文件对象。
• 而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象。

获取字节码对象（镜像）的三种方法

• a:Object类的getClass()方法,判断两个对象是否是同一个字节码文件
• b:静态属性class,锁对象
• c:Class类中静态方法forName(),读取配置文件

代码实现在程序运行时创建对象

public class Recflt {
public static void main(String[] args) {
try {
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
Class clazz = Class.forName(line);
Object object = clazz.newInstance();
System.out.println(object.toString());
} catch (Exception e) {
e.printStackTrace();
}
}
}

通过反射获取方法与变量

• Constructor

  • Class类的newInstance()方法是使用该类无参的构造函数创建对象, 如果一个类没有无参的构造函数, 就不能这样创建了,可以调用Class类的getConstructor(String.class,int.class)方法获取一个指定的构造函数然后再调用Constructor类的newInstance(“张三”,20)方法创建对象

• Field
  Class.getField(String)方法可以获取类中的指定字段(可见的),

      如果是私有的可以用getDeclaedField("name")方法获取,
  
      通过set(obj, "李四")方法可以设置指定对象上该字段的值, 
  
      如果是私有的需要先调用setAccessible(true)设置访问权限,
  
      用获取的指定的字段调用get(obj)可以获取指定对象中该字段的值
  

• Method
  Class.getMethod(String, Class…) 和 Class.getDeclaredMethod(String, Class…)方法可以获取类中的指定方法
  调用invoke(Object, Object…) 可以调用该方法

线程

进程：正在执行的应用程序
执行路径：一个应用程序从执行到结束的整个过程成为执行路径

什么是线程

* 线程是程序执行的一条路径, 一个进程中可以包含多条线程
* 多线程并发执行可以提高程序的效率, 可以同时完成多项工作
* 一个进程至少包含一个线程，线程控制着进程

多线程并行和并发的区别

• 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
• 并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。

Java程序运行原理

Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。

JVM的启动是多线程的吗

 JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

多线程实现方式

1.继承Thread

• 定义类继承Thread
• 重写run方法
• 把新线程要做的事写入run方法
• 创建线程对象
• 开启新线程用start方法
  2.实现Runnable接口
• 定义类实现Runnable接口
• 实现run方法
• 把新线程要做的事写入run方法
• 创建自定义的Runnable的子类对象
• 创建Thread，传入Runnable
• 调用start方法开启新线程

两种方式的区别

• 继承Thread
  • 好处是:可以直接使用Thread类中的方法,代码简单
  • 弊端是:如果已经有了父类,就不能用这种方法
• 实现Runnable接口
  • 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
  • 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

匿名内部类实现线程两种方法

• 继承Thread类
  new Thread() { //1,new 类(){}继承这个类
  public void run() { //2,重写run方法
  for(int i = 0; i < 3000; i++) { //3,将要执行的代码,写在run方法中
  System.out.println(“aaaaaaaaaaaaaaaaaaaaaaaaaaaa”);
  }
  }
  }.start();

• 实现Runnable接口
  new Thread(new Runnable(){ //1,new 接口(){}实现这个接口
  public void run() { //2,重写run方法
  for(int i = 0; i < 3000; i++) { //3,将要执行的代码,写在run方法中
  System.out.println(“bb”);
  }
  }
  }).start();

多线程
线程方法：
1.getName()
2.SetName(String)
3.Thread.currentThread()用于获取当前线程的对象

休眠线程

Thread.sleep毫秒, 控制当前线程休眠若干毫秒

守护线程

setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出

加入线程

• join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
• join(int), 可以等待指定的毫秒之后继续

礼让线程

yield让出CPU

线程优先级设置

setPriority()方法，值越高，优先级越高一般最大值为10

同步代码块

线程安全的代码块就是同步代码块，当多线程并发，有多段代码同步执行时，需要某一段代码执行过程中CPU不要切换到其他线程工作，需要用到同步线程
使用synchronized关键字加上一个锁对象来定义一段代码，这段代码就是同步代码块，如果多个代码块赢得同一个锁对象，他们是同步的。

同步方法

使用synchronized关键字修饰一个方法，该方法中所有代码都是同步的
非静态方法同步的锁：this
静态方法同步的锁：字节码对象

死锁

多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁

线程之间的通信

多线程并发执行时，在默认情况下时CPU随即切换线程的，如果希望有规律的执行，就可以只用通信
实现代码如下
public class Maindd {
private static Object object = new Object();
private static boolean flag = true;
public static void main(String[] args) {
new Thread() {
public void run() {
synchronized (object) {
try {
for(int i = 1; i <= 54; i++) {
System.out.print(i+" ");
if(i % 2 == 0) {
flag = false;
object.wait();
}
object.notify();
}
} catch (Exception e) {
e.printStackTrace();
}
}
};
}.start();

		new Thread() {
			public void run() {
				synchronized (object) {
					try {
						for(int i = 65; i <= 90; i++) {
							if(flag) {
								object.wait();
							}
							System.out.print((char)i+" ");
							flag = true;
							object.notify();
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
				}	
			};
		}.start();
	}
}
wait()方法：线程进入等待池，等待唤醒
notify()方法：用于唤醒正在等待的线程
这两个方法必须在同步代码中执行，使用同步锁对象来调用
如果多个线程之间通信，要使用notifyAll()通知所有线程

线程的五种状态

• 新建状态
  线程被创建之后进入新建状态
• 就绪状态：也称作“可执行状态”，线程对象创建之后，其他线程调用该对象的start()方法，启动该线程
  处于就绪状态的线程随时准备抢占CPU
• 运行状态：线程抢占CPU权限进行执行
• 阻塞状态：线程因为某种原因放弃CPU，暂时停止运行，直到线程进入就绪状态，才有机会进入执行状态
  1.等待阻塞：调用线程的wait()方法，让线程等待某工作的完成
  2.同步阻塞：线程在获取synchronized同步锁失败，进入同步阻塞状态
  3.其他阻塞：调用线程的sleep()方法，join()方法或者发出I/O请求时，线程会进入阻塞状态，处理完成之后，线程重新转入就绪状态
• 死亡状态：线程执行完或因异常退出run()方法，线程结束生命周期。