Java多线程
引言
什么是进程，线程？
进程：
资源分配最小的单位，cpu从磁盘中读取一段程序到内存中，该执行程序的实例就叫做进程。一个程序如果被cpu多次读取到内存中，则变成多个独立的进程。
线程 :
线程是程序执行的最小单位，在一个进程中可以有多个不同的线程。
线程的应用实例：
同一个应用程序中(进程)，更好的并行处理。
例子：手写一个文本编辑器需要多少个线程？
为什么需要使用多线程？
采用多线程的形式执行代码，目的是为了提高程序开发的效率。
串行、并行的区别
CPU分时间片交替执行，宏观并行，微观串行，由OS负责调度。如今的CPU已经发展到了多核CPU，真正存在并行。
CPU调度算法
多线程是不是一定提高效率？ 不一定，需要了解cpu调度的算法。
CPU调度算法：
如果在生产环境中，开启很多线程，但是我们的服务器核数很低，我们这么多线程会在cpu上做上下文切换，反而会降低效率。
使用线程池来限制线程数和cpu数相同会比较好。
复制代码一、Java多线程基础
创建线程的方式
- 继承
Thread类创建线程 - 实现
Runnable接口创建线程 - 使用匿名内部类形式创建线程
- 使用
Lambda表达式创建 - 使用
Callable和Future创建线程 - 使用线程池创建
- Spring中的
@Async创建
下面我们一一举例：
1.继承Thread类创建线程
public class ThreadTest extends Thread{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线程,线程一");
}
}
/* 创建对象进入初始状态，调用start()进入就绪状态。直接调用run()方法，相当于在main中执行run。并不是新线程*/
public static void main(String[] args) {
ThreadTest t = new ThreadTest();
//这里调用start方法启动线程
t.start();
}
}
复制代码2.实现Runnable接口创建线程
public class ThreadTest02 {
public static void main(String[] args) {
// 创建线程对象
Thread t = new Thread(new Thread01());
// 开启线程
t.start();
}
}
class Thread01 implements Runnable{
/**
* 这里实现父接口Runnable的run方法
*/
@Override
public void run() {
// 获取当前线程的名字
System.out.println(Thread.currentThread().getName() + "我是一个分支线程");
}
}
复制代码3.使用匿名内部类形式创建线程
public class ThreadTest03 {
public static void main(String[] args) {
// 这里使用匿名对象去实现Rnnable接口
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() +"我是一个分支接口");
}
});
t.start();
}
}
复制代码4.使用Lambda表达式创建
public class Thread02 {
public static void main(String[] args) {
new Thread(() -> System.out.println(Thread.currentThread().getName()+"我是子线程")).start();
}
}
复制代码5.使用Callable和 Future创建线程
Runnable的缺点：
1. run没有返回值
2. 不能抛异常
Callable接口允许线程有返回值，也允许线程抛出异常
Future接口用来接受返回值
复制代码public class Thread03 implements Callable<Integer> {
/**
* 当前线程需要执行的代码，返回结果
* @return 1
* @throws Exception
*/
@Override
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName()+"返回1");
return 1;
}
}
复制代码public static void main(String[] args) throws ExecutionException, InterruptedException {
Thread03 callable = new Thread03();
FutureTask<Integer> integerFutureTask = new FutureTask<Integer>(callable);
new Thread(integerFutureTask).start();
//通过api获取返回结果，主线程需要等待子线程返回结果
Integer result = integerFutureTask.get();
System.out.println(Thread.currentThread().getName()+","+result); // main,1
}
复制代码6.使用线程池创建
public class ThreadExecutor {
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"我是子线程1");
}
});
executorService.submit(new Thread03()); //submit一个线程到线程池
}
}
复制代码7.Spring中的@Async创建
第一步：在入口类中开启异步注解
@SpringBootApplication
@EnableAsync
复制代码第二步：在当前方法上加上@Async
@Component
@Slf4j
public class Thread01 {
@Async
public void asyncLog(){
try {
Thread.sleep(3000);
log.info("<2>");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
复制代码第三步：验证测试
@RestController
@Slf4j
public class Service {
@Autowired
private Thread01 thread01;
@RequestMapping("test")
public String Test(){
log.info("<1>");
thread01.asyncLog();
log.info("<3>");
return "test";
}
}
复制代码访问localhost:8080/test查看日志为：
Thread中的常用的方法
1.Thread.currentThread() 方法可以获得当前线程
java中的任何一段代码都是执行在某个线程当中的，执行当前代码的线程就是当前线程。
2.setName()/getName
thread.setName(线程名称) //设置线程名称
thread.getName() //返回线程名称
复制代码通过设置线程名称，有助于调试程序，提高程序的可读性，建议为每一个线程设置一个能够体现该线程功能的名称。
3.isAlive()
thread.isAlive() //判断当前线程是否处于活动状态
复制代码4.sleep()
Thread.sleep(millis); //让当前线程休眠指定的毫秒数
复制代码实例：计时器(一分钟倒计时)
/**
* @author 满满
* createDate 2022/2/28 13:21
* 关于线程的sleep方法：
* static void Sleep(long millis)
* 1. 静态方法 ： Thread.sleep(1000 * 5);
* 2. 参数是毫秒
* 3. 作用 ：让当前线程进入休眠，进入阻塞状态，放弃占有CPU时间片，让其他线程去使用。
* 如果这行代码出现在A线程中 A线程就会进入休眠状态
* 如果这行代码出现在B线程中 B线程就会进入休眠状态
*/public class ThreadTest05 {
public static void main(String[] args) {
//让当前线程进入休眠状态 睡眠5秒
// 当前线程是主线程
/**
try {
* Thread.sleep(1000 * 5);
* } catch (InterruptedException e) {
* e.printStackTrace();
* }
* System.out.println("hell0,world");
*/
for (int i = 0; i <=20 ; i++) {
System.out.println(Thread.currentThread().getName() +" ---->>" + i );
try {
Thread.sleep( 1000 * 1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
复制代码5.getId() java中的线程都有一个唯一编号
6.yield() 放弃当前的cpu资源
Thread.yield(); //可以让线程由运行转为就绪状态
复制代码7.setPriority() 设置线程的优先级
thread.setPriority(num); 设置线程的优先级，取值为1-10，如果超过范围会抛出异常 IllegalArugumentExption;
优先级越高的线程，获得cpu资源的概率越大。（抢夺的CPU时间片就越多即概率越大）
优先级本质上只是给线程调度器一个提示信息，以便于线程调度器决定先调度哪些线程。不能保证优先级高的线程先运行。
java优先级设置不当，可能导致某些线程永远无法得到运行，产生了线程饥饿。
线程的优先级并不是设置的越高越好，在开发时不必设置线程的优先级。
复制代码8.interrupt()中断线程 (Thread中的方法。)
因为interrupt()方法只能中断阻塞过程中的线程而不能中断正在运行过程中的线程。
在运行中的线程使用：
注意调用此方法仅仅是在当前线程打一个停止标志，并不是真正的停止线程。
例如在线程1中调用线程b的interrupt(),在b线程中监听b线程的中断标志，来处理结束。
复制代码package se.high.thread;
/**
* @author gaoziman
*/
public class YieldTest extends Thread {
@Override
public void run() {
for (int i = 1; i < 1000; i++) {
// 判断中断标志
if (this.isInterrupted()){
//如果为true，结束线程
//break;
return;
}
System.out.println("thread 1 --->"+i);
}
}
}
复制代码package se.high.thread;
/**
* @author gaoziman
*/
public class Test {
public static void main(String[] args) {
YieldTest t1 = new YieldTest();
t1.start(); //开启子线程
//当前线程main线程
for (int i = 1; i < 100; i++) {
System.out.println("main --->" + i);
}
//打印完main线程中100个后，中断子线程,仅仅是个标记，必须在线程中处理
t1.interrupt();
}
}
复制代码9.setDaemon() 守护线程
//线程启动前
thread.setDaemon(true);
thread.start();
复制代码Java中的线程分为用户线程与守护线程
守护线程是为其他线程提供服务的线程，如垃圾回收(GC)就是一个典型的守护线程。
守护线程不能单独运行，当jvm中没有其他用户线程，只有守护线程时，守护线程会自动销毁，jvm会自动退出。
线程的状态（线程的生命周期）
**线程的状态： ** getState()
二、线程安全原理篇
多线程的好处：
- 提高了系统的
吞吐量，多线程编程可以使一个进程有多个并发(concurrent)。 - 提高
响应性，服务器会采用一些专门的线程负责用户的请求处理，缩短了用户的等待时间。 充分利用多核处理器资源，通过多线程可以充分的利用CPU资源。
多线程的问题：
线程安全问题，多线程共享数据时，如果没有采取正确的并发访问控制措施，就可能产生数据一致性问题，如读取脏数据（过期的数据），如丢失数据更新。
线程活性(thread liveness)问题。由于程序自身的缺陷或者由资源稀缺性导致的线程一直处于非RUNNABLE状态，这就是线程活性问题。
常见的线程活性问题：
1.死锁 （DeadLock） 鹬蚌相争 2.锁死 （Lockout） 睡美人故事中王子挂啦 3.活锁 （LiveLock） 类似小猫一直咬自己的尾巴，但是咬不到 4.饥饿 （Starvation）类似于健壮的雏鸟总是从母鸟嘴中抢食物。
上下文切换(Context Switch)处理器从执行一个线程切换到执行另外一个线程。
可靠性可能会由一个线程导致JVM意外终止，其他线程也无法执行。线程安全问题
什么是线程安全问题？
当多个线程对同一个对象的实例变量，做写(修改)的操作时，可能会受到其他线程的干扰，发生线程安全的问题。
原子性(Atomic)：
不可分割，访问(读，写)某个共享变量的时候，从其他线程来看，该操作要么已经执行完毕，要么尚未发生。其他线程看不到当前操作的中间结果。 访问同一组共享变量的原子操作是不能够交错的，如现实生活中从ATM取款。
java中有两种方式实现原子性：
1.锁 ：锁具有排他性，可以保证共享变量某一时刻只能被一个线程访问。
2.CAS指令 ：直接在硬件层次上实现，看做是一个硬件锁。
复制代码可见性(visbility)：
在多线程环境中，一个线程对某个共享变量更新之后，后续其他的线程可能无法立即读到这个更新的结果。
如果一个线程对共享变量更新之后，后续访问该变量的其他线程可以读到更新的结果，称这个线程对共享变量的更新对其他线程可见。否则称这个线程对共享变量的更新对其他线程不可见。
多线程程序因为可见性问题可能会导致其他线程读取到旧数据(脏数据)。
有序性(Ordering)：
是指在什么情况下一个处理器上运行的一个线程所执行的 内存访问操作在另外一个处理器运行的其他线程来看是乱序的(Out of Order)
乱序: 是指内存访问操作的顺序看起来发生了变化。
JVM与JMM
JVM运行时数据区
先谈一下运行时数据区，下面这张图相信大家一点都不陌生：
对于每一个线程来说，栈都是私有的，而堆是共有的。
也就是说在栈中的变量（局部变量、方法定义参数、异常处理器参数）不会在线程之间共享，也就不会有内存可见性（下文会说到）的问题，也不受内存模型的影响。而在堆中的变量是共享的，本文称为共享变量。
所以，内存可见性是针对的共享变量。
出现线程不安全的例子
public class ThreadCount implements Runnable{
private int count =100;
@Override
public void run() {
while(true){
if (count>0){
count--;
System.out.println(Thread.currentThread().getName()+"---->"+count);
}
}
}
public static void main(String[] args) {
ThreadCount threadCount = new ThreadCount();
new Thread(threadCount).start();
new Thread(threadCount).start();
}
}
复制代码如何解决线程安全的问题？
核心思想：上锁
在同一个JVM中，多个线程需要竞争锁的资源，最终只能够有一个线程能够获取到锁，多个线程同时抢一把锁，哪个线程能够获得到锁，谁就可以执行该代码，如果没有获取锁成功，中间需要经历锁的升级过程，如果一直没有获取到锁则会一直阻塞等待。
例如上述情况下如何上锁呢？？
public class ThreadCount implements Runnable{
private int count =100;
@Override
public void run() {
while(true){
synchronized (this){
if (count>0){
/*线程0 线程1 同时获取this锁，假设线程0 获取到this锁，意味着线程1没有获取到锁则会等待。等线程0执行完count-- 释放锁资源后，就会唤醒线程1 从新进入到获取锁的资源。 获取锁与释放锁全部由虚拟机实现*/
count--;
System.out.println(Thread.currentThread().getName()+"----"+count);
}
}
}
}
public static void main(String[] args) {
ThreadCount threadCount = new ThreadCount();
new Thread(threadCount).start();
new Thread(threadCount).start();
}
}
复制代码三、线程同步
线程同步可以理解为线程之间按照一定的顺序执行。
在我们的线程之间，有一个同步的概念。什么是同步呢，假如我们现在有2位正在抄暑假作业答案的同学：线程A和线程B。当他们正在抄的时候，老师突然来修改了一些答案，可能A和B最后写出的暑假作业就不一样。我们为了A,B能写出2本相同的暑假作业，我们就需要让老师先修改答案，然后A，B同学再抄。或者A，B同学先抄完，老师再修改答案。这就是线程A，线程B的线程同步。
复制代码线程安全的产生就是因为多线程之间没有同步，线程同步机制是一套用于协调线程之间的数据访问机制，该机制可以保证线程安全。
Java平台提供的线程机制包括锁，volatile关键字，final关键字，static关键字，以 及相关的API,Objet.wait(); Object.notify()等。
锁的概念
线程安全的问题的产生前提是多个线程并发访问共享数据，将多个线程对共享数据的并发转换为串行访问，即一个共享数据一次只能被一个线程所访问。锁就是通过这种方式来保证线程安全的。
JVM把锁分为内部锁和显示锁两种。内部所通过synchronized关键字实现；显示锁通过java.concurrent.locks.lock接口实现类实现的。
**锁的作用：**锁可以实现对共享数据的安全访问，保障线程的原子性，可见性，与有序性。
- 锁是通过互斥保障原子性，一个锁只能被一个线程所持有的，这就保证临界区代码一次只能被一个线程执行，使得操作不可分割，保证原子性。
- 可见性的保障是通过写线程冲刷处理器的缓存和读线程刷新处理缓存这两个动作实现的。在Java中。锁的获得隐含着刷新处理器缓存的动作，锁的释放隐含着刷新处理器缓存的动作。保证写线程对数据的修改，第一时间推送到刷新处理器的高速缓存中，保证读线程的第一时间可见。
- 锁能够保证有序性，写线程在临界区所执行的临界区看来像是完全按照源码顺序执行的。
注意：使用锁来保证线程的安全性必须满足以下条件：
- 这些线程在访问共享数据时，必须使用同一个锁。
- 这些线程即使仅仅是读共享数据，也需要使用锁。
内部锁：synchronized
java中的每个对象都有一个与之关联的内部锁(这种锁也被称为监视器Monitor)，这种锁是一种排他锁，可以保证原子性，可见性，有序性。
所谓``“临界区”，指的是某一块代码区域，它同一时刻只能由一个线程执行。如果synchronized`关键字在方法上，那临界区就是整个方法内部。而如果是使用 synchronized代码块，那临界区就指的是代码块内部的区域。
synchronized的几种使用场景：
1、synchronized修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
synchronized(对象锁){
同步代码块，可以在同步代码块中访问共享数据
}
-------------------------------------------------------------------------------
package se.high.thread.intrinsiclock;
/**
* @author gaoziman
* 同步代码块
*/
public class Test01 {
public static void main(String[] args) {
//创建两个线程，分别调用mm()方法
//先创建Test01对象，通过对象名调用mm()方法
Test01 obj = new Test01();
new Thread(new Runnable() {
@Override
public void run() {
obj.mm(); //使用的锁对象this就是obj对象
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
obj.mm(); // 使用的锁对象this就是obj对象
}
}).start();
}
//定义一个方法，打印100行字符串
public void mm(){
//使用this当前对象作为锁对象
synchronized (this){
for (int i = 0; i <100; i++) {
System.out.println(Thread.currentThread().getName()+"---->"+i);
}}
}
}
复制代码2、synchronized修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
package se.high.thread.intrinsiclock;
/**
* @author 王泽
* 同步实例方法，把整个方法体作为同步代码块。
* 默认的锁对象是this锁对象。
*/
public class Test02 {
public static void main(String[] args) {
//创建两个线程，分别调用mm()方法 mm2
Test02 obj = new Test02();
new Thread(new Runnable() {
@Override
public void run() {
obj.mm(); //使用的锁对象this就是obj对象
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
obj.mm2(); // 使用的锁对象this就是obj对象
}
}).start();
}
public void mm(){
//使用this当前对象作为锁对象
synchronized (this){
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"---->"+i);
}}
}
/**
* 同步实例方法，同步实例方法，默认this作为锁对象。
*/
public synchronized void mm2(){
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"--->"+i);
}
}
}
复制代码3、synchronized修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
// 关键字在静态方法上，锁为当前Class对象
public static synchronized void classLock() {
// code
}
复制代码等价于===
// 关键字在代码块上，锁为括号里面的对象
public void blockLock() {
synchronized (this.getClass()) {
// code
}
}
复制代码4、synchronized修饰一个类，其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象。
总结：
同步代码块比同步方法效率更高。 脏读出现的原因是对共享数据的修改与对共享数据的读取不同步。需要对读取数据的代码块同步。 线程出现异常会自动释放锁。
多线程访问同步方法的7种情况
1、两个线程同时访问一个对象的同步方法
答：串行执行
2、两个线程访问的是两个对象的同步方法
答：并行执行，因为两个线程持有的是各自的对象锁，互补影响。
3、两个线程访问的是synchronized的static方法
答：串行执行，持有一个类锁
4、同时访问同步方法和非同步方法
答：并行执行，无论是同一对象还是不同对象，普通方法都不会受到影响
5、访问同一对象的不同的普通同步方法
答：串行执行，持有相同的锁对象
6、同时访问静态的synchronized方法和非静态的synchronized方法
答：并行执行，因为一个是持有的class类锁，一个是持有的是this对象锁，不同的锁，互补干扰。
7、方法抛出异常后，会释放锁
答：synchronized无论是正常结束还是抛出异常后，都会释放锁，而lock必须手动释放锁才可以。
死锁的问题
死锁是这样一种情形：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
java 死锁产生的四个必要条件：
1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用 2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。 3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。 4、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。
当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。下面用java代码来模拟一下死锁的产生：
package se.high.thread.intrinsiclock;
import javax.security.auth.Subject;
/**
* @author gaoziman
* 演示死锁问题。
* 在多线程程序中，同步时可能需要使用多个锁，如果获得锁的顺序不一致，可能会导致死锁。
*/
public class DeadLock {
public static void main(String[] args) {
SubThread t1 =new SubThread();
t1.setName("a");
t1.start();
SubThread t2 = new SubThread();
t2.setName("b");
t2.start();
}
static class SubThread extends Thread{
private static final Object yitian = new Object();
private static final Object tulong = new Object();
@Override
public void run() {
if ("a".equals(Thread.currentThread().getName())){
synchronized (yitian){
System.out.println("a线程获得了倚天剑，爽翻了，再来个屠龙刀就好了...");
synchronized (tulong){
System.out.println("a线程获得了倚天剑和屠龙刀，直接称霸武林...");
}
}
}
if ("b".equals(Thread.currentThread().getName())){
synchronized (tulong){
System.out.println("b线程获得了屠龙宝刀，得劲,谁也不给....");
synchronized (yitian){
System.out.println("b线程获得了屠龙后又来把倚天剑....b称霸武林");
}
}
}
}
}
}
复制代码解决死锁：
当需要获得多个锁时，所有线程获得锁的顺序保持一致。
四、线程之间的通信
众所周知线程都有自己的线程栈，那么线程之间是如何保证通信的呢？下面来分析：
等待/通知机制
什么是等待通知机制？
举例：吃自助的时候吃现做的一些饭，放到台子上才能拿。
在单线程编程中，要执行的操作需要满足一定的条件才能执行，可以把这个操作放在if语句块中。
在多线程编程中，可能A线程条件没有满足只是暂时的，稍后其他的线程B可能会更新条件使得A线程的条件得到满足，可以将A线程暂停，直到他的条件得到满足后再将A线程唤醒。
伪代码：
atomic{
while（条件不成立）{
等待
}
条件满足后当前线程被唤醒，继续执行下面的操作
}
复制代码等待通知机制的实现：
Object类中的wait()方法，可以使当前执行代码的线程等待。暂停执行，知道接受到通知或被中断为止。
注意：
- wait()方法只能在同步代码块中由锁对象调用。
- 调用wait()方法后，当前线程会释放锁。
伪代码：
//在调用wait()方法前获得对象的内部锁
synchronized(锁对象){
while(条件不成立){
//通过锁对象调用wait()方法暂停线程，释放锁对象
锁对象.wait();
}
//线程的条件满足了继续向下执行
}
复制代码Object类的 notify()可以唤醒线程，该方法也必须在同步代码块中由锁对象调用。没有使用锁对象调用wait()/notify()会抛出异常。
如果有多个等待的线程，**notify()方法只能唤醒其中的一个，并不会立即释放锁对象。**一般将notify方法放在同步代码块的最后。
伪代码：
synchronized(锁对象){
执行修改保护条件的代码
唤醒其他线程
锁对象.notify();
}
复制代码下面我们来看一个了例子：
package se.high.thread.wait;
/**
* @author 结构化思维wz
* 用notify唤醒等待的线程
*/
public class Test01 {
public static void main(String[] args) {
String lock = "wzjiayou"; //定义一个字符串作为锁对象
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock){
System.out.println("线程1开始等待-->"+System.currentTimeMillis());
try {
lock.wait(); //线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程1结束等待-->"+System.currentTimeMillis());
}
}
});
/**
* 定义线程2，用来唤醒线程1
*/
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
//notify需要在同步代码块中由锁对象调用
synchronized (lock){
System.out.println("线程2开始唤醒"+System.currentTimeMillis());
lock.notify();
System.out.println("线程2结束唤醒"+System.currentTimeMillis());
}
}
});
t1.start(); //开启t1线程,main线程谁3秒，确保t1等待
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
复制代码执行结果：
线程1开始等待-->1633345984896
线程2开始唤醒1633345987897
线程2结束唤醒1633345987897
线程1结束等待-->1633345987897
进程已结束，退出代码为 0
复制代码interrupt()方法会中断wait()
当线程处于wait()等待状态时，调用线程对象的interrupt()方法会中断线程等待状态，会产生InterruptedExceptiont异常。
notify()与notifyAll()
notify()一次只能唤醒一个线程，如果有多个等待的线程，只能随机唤醒其中的某一个；想要唤醒所有的线程，需要调用notifyAll();
wait(long)
如果在参数指定的时间内没有被唤醒，超时后会自动唤醒。
通知过早
线程wait()等待后，可以调用notify()唤醒线程，如果notify()唤醒过早，在等待之前就调用了notify()可能会打乱程序正常的执行逻辑。
在应用中，我们为了保证t1等待后才让t2唤醒。如果t2线程先唤醒，就不让t1等待了。
可以设置一个Boolean变量，通知后设为false，如果为true再等待。
wait() 等待条件发生了变化
在使用wait(),notify(),注意wait条件发生的了变化，也可能导致逻辑的混乱。
*生产者消费者模式
生产者消费者问题（Producer-consumer problem），也称有限缓冲问题（Bounded-buffer problem），是一个多线程同步问题的经典案例。生产者生成一定量的数据放到缓冲区中，然后重复此过程；与此同时，消费者也在缓冲区消耗这些数据。生产者和消费者之间必须保持同步，要保证生产者不会在缓冲区满时放入数据，消费者也不会在缓冲区空时消耗数据。不够完善的解决方法容易出现死锁的情况，此时进程都在等待唤醒。
示意图：
解决思路：
-
采用某种机制保护生产者和消费者之间的同步。有较高的效率，并且易于实现，代码的可控制性较好，属于常用的模式。
-
在生产者和消费者之间建立一个管道。管道缓冲区不易控制，被传输数据对象不易于封装等，实用性不强。
解决问题的核心：
保证同一资源被多个线程并发访问时的完整性。常用的同步方法是采用信号或加锁机制，保证资源在任意时刻至多被一个线程访问。
wait() / notify()方法
当缓冲区已满时，生产者线程停止执行，放弃锁，使自己处于等待状态，让其他线程执行；
当缓冲区已空时，消费者线程停止执行，放弃锁，使自己处于等待状态，让其他线程执行。
当生产者向缓冲区放入一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态； 当消费者从缓冲区取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态。
仓库Storage.java
import java.util.LinkedList;
public class Storage {
// 仓库容量
private final int MAX_SIZE = 10;
// 仓库存储的载体
private LinkedList<Object> list = new LinkedList<>();
public void produce() {
synchronized (list) {
/*仓库满的情况*/
while (list.size() + 1 > MAX_SIZE) {
System.out.println("【生产者" + Thread.currentThread().getName()
+ "】仓库已满");
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/*生产者生产*/
list.add(new Object());
System.out.println("【生产者" + Thread.currentThread().getName()
+ "】生产一个产品，现库存" + list.size());
list.notifyAll();
}
}
public void consume() {
synchronized (list) {
/*仓库空了*/
while (list.size() == 0) {
System.out.println("【消费者" + Thread.currentThread().getName()
+ "】仓库为空");
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/*消费者消费*/
list.remove();
System.out.println("【消费者" + Thread.currentThread().getName()
+ "】消费一个产品，现库存" + list.size());
list.notifyAll();
}
}}
复制代码生产者：
public class Producer implements Runnable{
private Storage storage;
public Producer(){}
public Producer(Storage storage){
this.storage = storage;
}
@Override
public void run(){
while(true){
try{
Thread.sleep(1000);
storage.produce();
}catch (InterruptedException e){
e.printStackTrace();
}
}
}}
复制代码消费者
public class Consumer implements Runnable{
private Storage storage;
public Consumer(){}
public Consumer(Storage storage){
this.storage = storage;
}
@Override
public void run(){
while(true){
try{
Thread.sleep(3000);
storage.consume();
}catch (InterruptedException e){
e.printStackTrace();
}
}
}}
复制代码Main：
public class Main {
public static void main(String[] args) {
Storage storage = new Storage();
Thread p1 = new Thread(new Producer(storage));
Thread p2 = new Thread(new Producer(storage));
Thread p3 = new Thread(new Producer(storage));
Thread c1 = new Thread(new Consumer(storage));
Thread c2 = new Thread(new Consumer(storage));
Thread c3 = new Thread(new Consumer(storage));
p1.start();
p2.start();
p3.start();
c1.start();
c2.start();
c3.start();
}}
复制代码运行结果
【生产者p1】生产一个产品，现库存1
【生产者p2】生产一个产品，现库存2
【生产者p3】生产一个产品，现库存3
【生产者p1】生产一个产品，现库存4
【生产者p2】生产一个产品，现库存5
【生产者p3】生产一个产品，现库存6
【生产者p1】生产一个产品，现库存7
【生产者p2】生产一个产品，现库存8
【消费者c1】消费一个产品，现库存7
【生产者p3】生产一个产品，现库存8
【消费者c2】消费一个产品，现库存7
【消费者c3】消费一个产品，现库存6
【生产者p1】生产一个产品，现库存7
【生产者p2】生产一个产品，现库存8
【生产者p3】生产一个产品，现库存9
【生产者p1】生产一个产品，现库存10
【生产者p2】仓库已满
【生产者p3】仓库已满
【生产者p1】仓库已满
【消费者c1】消费一个产品，现库存9
【生产者p1】生产一个产品，现库存10
【生产者p3】仓库已满
。。。。。。以下省略
复制代码一个生产者线程运行produce方法，睡眠1s；一个消费者运行一次consume方法，睡眠3s。此次实验过程中，有3个生产者和3个消费者，也就是我们说的多对多的情况。仓库的容量为10，可以看出消费的速度明显慢于生产的速度，符合设定。
注意：
notifyAll()方法可使所有正在等待队列中等待同一共享资源的“全部”线程从等待状态退出，进入可运行状态。此时，优先级最高的哪个线程最先执行，但也有可能是随机执行的，这要取决于JVM虚拟机的实现。即最终也只有一个线程能被运行，上述线程优先级都相同，每次运行的线程都不确定是哪个，后来给线程设置优先级后也跟预期不一样，还是要看JVM的具体实现吧。
join()
join()方法是Thread类的一个实例方法。它的作用是让当前线程陷入“等待”状态，等join的这个线程执行完成后，再继续执行当前线程。
有时候，主线程创建并启动了子线程，如果子线程中需要进行大量的耗时运算，主线程往往将早于子线程结束之前结束。
如果主线程想等待子线程执行完毕后，获得子线程中的处理完的某个数据，就要用到join方法了。(插队)
public class Join {
static class ThreadA implements Runnable {
@Override
public void run() {
try {
System.out.println("我是子线程，我先睡一秒");
Thread.sleep(1000);
System.out.println("我是子线程，我睡完了一秒");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(new ThreadA());
thread.start();
thread.join();
System.out.println("如果不加join方法，我会先被打出来，加了就不一样了");
}
}
复制代码注意join()方法有两个重载方法，一个是join(long)， 一个是join(long, int)。
实际上，通过源码你会发现，join()方法及其重载方法底层都是利用了wait(long)这个方法。
对于join(long, int)，通过查看源码(JDK 1.8)发现，底层并没有精确到纳秒，而是对第二个参数做了简单的判断和处理。
五、Callable与Future
通常来说，我们使用Runnable和Thread来创建一个新的线程。但是它们有一个弊端，就是run方法是没有返回值的。而有时候我们希望开启一个线程去执行一个任务，并且这个任务执行完成后有一个返回值。
JDK提供了Callable接口与Future接口为我们解决这个问题，这也是所谓的“异步”模型。
Callable接口
Callable与Runnable类似，同样是只有一个抽象方法的函数式接口。不同的是，Callable提供的方法是有返回值的，而且支持泛型。
@FunctionalInterface
public interface Callable<V> {
V call() throws Exception;
}
复制代码那一般是怎么使用Callable的呢？Callable一般是配合线程池工具ExecutorService来使用的。我们会在后续章节解释线程池的使用。这里只介绍ExecutorService可以使用submit方法来让一个Callable接口执行。它会返回一个Future，我们后续的程序可以通过这个Future的get方法得到结果。
这里可以看一个简单的使用demo：
// 自定义Callable
class Task implements Callable<Integer>{
@Override
public Integer call() throws Exception {
// 模拟计算需要一秒
Thread.sleep(1000);
return 2;
}
public static void main(String args[]) throws Exception {
// 使用
ExecutorService executor = Executors.newCachedThreadPool();
Task task = new Task();
Future<Integer> result = executor.submit(task);
// 注意调用get方法会阻塞当前线程，直到得到结果。
// 所以实际编码中建议使用可以设置超时时间的重载get方法。
System.out.println(result.get());
}
}
复制代码输出结果：
2
复制代码Future接口
Future接口只有几个比较简单的方法：
public abstract interface Future<V> {
public abstract boolean cancel(boolean paramBoolean);
public abstract boolean isCancelled();
public abstract boolean isDone();
public abstract V get() throws InterruptedException, ExecutionException;
public abstract V get(long paramLong, TimeUnit paramTimeUnit)
throws InterruptedException, ExecutionException, TimeoutException;
}
复制代码cancel方法是试图取消一个线程的执行。
注意是试图取消，并不一定能取消成功。因为任务可能已完成、已取消、或者一些其它因素不能取消，存在取消失败的可能。boolean类型的返回值是“是否取消成功”的意思。参数paramBoolean表示是否采用中断的方式取消线程执行。
所以有时候，为了让任务有能够取消的功能，就使用Callable来代替Runnable。如果为了可取消性而使用 Future但又不提供可用的结果，则可以声明 Future<?>形式类型、并返回 null作为底层任务的结果。
FutureTask类
上面介绍了Future接口。这个接口有一个实现类叫FutureTask。FutureTask是实现的RunnableFuture接口的，而RunnableFuture接口同时继承了Runnable接口和Future接口：
public interface RunnableFuture<V> extends Runnable, Future<V> {
/**
* Sets this Future to the result of its computation
* unless it has been cancelled.
*/
void run();
}
复制代码那FutureTask类有什么用？为什么要有一个FutureTask类？前面说到了Future只是一个接口，而它里面的cancel，get，isDone等方法要自己实现起来都是非常复杂的。所以JDK提供了一个FutureTask类来供我们使用。
实例代码：
// 自定义Callable，与上面一样
class Task implements Callable<Integer>{
@Override
public Integer call() throws Exception {
// 模拟计算需要一秒
Thread.sleep(1000);
return 2;
}
public static void main(String args[]) throws Exception {
// 使用
ExecutorService executor = Executors.newCachedThreadPool();
FutureTask<Integer> futureTask = new FutureTask<>(new Task());
executor.submit(futureTask);
System.out.println(futureTask.get());
}
}
复制代码使用上与第一个Demo有一点小的区别。首先，调用submit方法是没有返回值的。这里实际上是调用的submit(Runnable task)方法，而上面的Demo，调用的是submit(Callable task)方法。
然后，这里是使用FutureTask直接取get取值，而上面的Demo是通过submit方法返回的Future去取值。
在很多高并发的环境下，有可能Callable和FutureTask会创建多次。FutureTask能够在高并发环境下确保任务只执行一次。
反射
一、反射的概述
Java反射机制是实在运行状态中，对于任意一个类，都能够知道这个类的属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取信息以及动态调用对象的方法的功能我们称之为Java反射机制。
想要剖析一个类，必须要获取该类的的字节码文件对象。而剖析使用的就是Class类的方法，所以要先获取一个字节码文件对应的Class类型的对象。
*以上的总结就是什么是反射*
反射就是把java类中的各种成分映射成一个个的Java对象
例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。
（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述） 如图是类的正常加载过程：反射的原理在与class对象。 熟悉一下加载的时候：Class对象的由来是将class文件读入内存，并为之创建一个Class对象。
其中这个Class对象很特殊。我们先了解一下这个C lass类
二、查看Class类在Java中api详解（查阅文档）
Class 类的实例表示正在运行的 Java 应用程序中的类和接口。也就是jvm中有N多的实例每个类都有该Class对象。（包括基本数据类型）
Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了。
没有公共的构造方法，方法共有64个太多了。咱们只需要了解一些常用的即可
三、反射的使用
下面我们来举一个例子：
先写一个Student类。
1、获取Class对象的三种方式
- Object ——> getClass();
- 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
- 通过Class的静态方法：forName（String className）(常用)
其中1.1是因为Object类中的getClass方法、因为所有类都继承Object类。从而调用Object类来获取
package fanshe;
/**
* 获取Class对象的三种方式
* 1 Object ——> getClass();
* 2 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
* 3 通过Class类的静态方法：forName（String className）(常用)
*/
public class Fanshe {
public static void main(String[] args) {
//第一种方式获取Class对象
Student stu1 = new Student();//这一new 产生一个Student对象，一个Class对象。
Class stuClass = stu1.getClass();//获取Class对象
System.out.println(stuClass.getName());
//第二种方式获取Class对象
Class stuClass2 = Student.class;
System.out.println(stuClass == stuClass2);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个
//第三种方式获取Class对象
try {
Class stuClass3 = Class.forName("fanshe.Student");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
复制代码注意：在运行期间，一个类，只有一个Class对象产生。
三种方式常用第三种，第一种对象都有了还要反射干什么。第二种需要导入类的包，依赖太强，不导包就抛编译错误。一般都第三种，一个字符串可以传入也可写在配置文件中等多种方法。
2、通过反射获取构造方法并使用：
student类：
package fanshe;
public class Student {
//---------------构造方法-------------------
//（默认的构造方法）
Student(String str){
System.out.println("(默认)的构造方法 s = " + str);
}
//无参构造方法
public Student(){
System.out.println("调用了公有、无参构造方法执行了。。。");
}
//有一个参数的构造方法
public Student(char name){
System.out.println("姓名：" + name);
}
//有多个参数的构造方法
public Student(String name ,int age){
System.out.println("姓名："+name+"年龄："+ age);//这的执行效率有问题，以后解决。
}
//受保护的构造方法
protected Student(boolean n){
System.out.println("受保护的构造方法 n = " + n);
}
//私有构造方法
private Student(int age){
System.out.println("私有的构造方法 年龄："+ age);
}
}
复制代码共有6个构造方法；
测试类：
package fanshe;
import java.lang.reflect.Constructor;
/*
* 通过Class对象可以获取某个类中的：构造方法、成员变量、成员方法；并访问成员；
*
* 1.获取构造方法：
* 1).批量的方法：
* public Constructor[] getConstructors()：所有"公有的"构造方法
public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
* 2).获取单个的方法，并调用：
* public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：
* public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；
*
* 调用构造方法：
* Constructor-->newInstance(Object... initargs)
*/
public class Constructors {
public static void main(String[] args) throws Exception {
//1.加载Class对象
Class clazz = Class.forName("fanshe.Student");
//2.获取所有公有构造方法
System.out.println("**********************所有公有构造方法*********************************");
Constructor[] conArray = clazz.getConstructors();
for(Constructor c : conArray){
System.out.println(c);
}
System.out.println("************所有的构造方法(包括：私有、受保护、默认、公有)***************");
conArray = clazz.getDeclaredConstructors();
for(Constructor c : conArray){
System.out.println(c);
}
System.out.println("*****************获取公有、无参的构造方法*******************************");
Constructor con = clazz.getConstructor(null);
//1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型
//2>、返回的是描述这个无参构造函数的类对象。
System.out.println("con = " + con);
//调用构造方法
Object obj = con.newInstance();
// System.out.println("obj = " + obj);
// Student stu = (Student)obj;
System.out.println("******************获取私有构造方法，并调用*******************************");
con = clazz.getDeclaredConstructor(char.class);
System.out.println(con);
//调用构造方法
con.setAccessible(true);//暴力访问(忽略掉访问修饰符)
obj = con.newInstance('男');
}
}
复制代码执行结果：
**********************所有公有构造方法*********************************
public fanshe.Student(java.lang.String,int)
public fanshe.Student(char)
public fanshe.Student()
************所有的构造方法(包括：私有、受保护、默认、公有)***************
private fanshe.Student(int)
protected fanshe.Student(boolean)
public fanshe.Student(java.lang.String,int)
public fanshe.Student(char)
public fanshe.Student()
fanshe.Student(java.lang.String)
*****************获取公有、无参的构造方法*******************************
con = public fanshe.Student()
调用了公有、无参构造方法执行了。。。
******************获取私有构造方法，并调用*******************************
public fanshe.Student(char)
姓名：男
复制代码调用方法：
1.获取构造方法： 1).批量的方法： public Constructor[] getConstructors()：所有"公有的"构造方法 public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
2).获取单个的方法，并调用： public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法： public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；
调用构造方法： Constructor-->newInstance(Object... initargs)
2、 newInstance是 Constructor类的方法（管理构造函数的类） api的解释为： newInstance(Object... initargs) 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。 它的返回值是T类型，所以newInstance是创建了一个构造方法的声明类的新实例对象。并为之调用
3、获取成员变量并调用
student类：
package fanshe.field;
public class Student {
public Student(){
}
//**********字段*************//
public String name;
protected int age;
char sex;
private String phoneNum;
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", sex=" + sex
+ ", phoneNum=" + phoneNum + "]";
}
}
复制代码测试类：
package fanshe.field;
import java.lang.reflect.Field;
/*
* 获取成员变量并调用：
*
* 1.批量的
* 1).Field[] getFields():获取所有的"公有字段"
* 2).Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有；
* 2.获取单个的：
* 1).public Field getField(String fieldName):获取某个"公有的"字段；
* 2).public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的)
*
* 设置字段的值：
* Field --> public void set(Object obj,Object value):
* 参数说明：
* 1.obj:要设置的字段所在的对象；
* 2.value:要为字段设置的值；
*
*/
public class Fields {
public static void main(String[] args) throws Exception {
//1.获取Class对象
Class stuClass = Class.forName("fanshe.field.Student");
//2.获取字段
System.out.println("************获取所有公有的字段********************");
Field[] fieldArray = stuClass.getFields();
for(Field f : fieldArray){
System.out.println(f);
}
System.out.println("************获取所有的字段(包括私有、受保护、默认的)********************");
fieldArray = stuClass.getDeclaredFields();
for(Field f : fieldArray){
System.out.println(f);
}
System.out.println("*************获取公有字段**并调用***********************************");
Field f = stuClass.getField("name");
System.out.println(f);
//获取一个对象
Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();
//为字段设置值
f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"
//验证
Student stu = (Student)obj;
System.out.println("验证姓名：" + stu.name);
System.out.println("**************获取私有字段****并调用********************************");
f = stuClass.getDeclaredField("phoneNum");
System.out.println(f);
f.setAccessible(true);//暴力反射，解除私有限定
f.set(obj, "18888889999");
System.out.println("验证电话：" + stu);
}
}
复制代码执行结果：
************获取所有公有的字段********************
public java.lang.String fanshe.field.Student.name
************获取所有的字段(包括私有、受保护、默认的)********************
public java.lang.String fanshe.field.Student.name
protected int fanshe.field.Student.age
char fanshe.field.Student.sex
private java.lang.String fanshe.field.Student.phoneNum
*************获取公有字段**并调用***********************************
public java.lang.String fanshe.field.Student.name
验证姓名：刘德华
**************获取私有字段****并调用********************************
private java.lang.String fanshe.field.Student.phoneNum
验证电话：Student [name=刘德华, age=0, sex=
复制代码由此可见 调用字段时：需要传递两个参数：
Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student(); //为字段设置值 f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华" 第一个参数：要传入设置的对象，第二个参数：要传入实参
4、获取成员方法并调用
student类：
package fanshe.method;
public class Student {
//**************成员方法***************//
public void show1(String s){
System.out.println("调用了：公有的，String参数的show1(): s = " + s);
}
protected void show2(){
System.out.println("调用了：受保护的，无参的show2()");
}
void show3(){
System.out.println("调用了：默认的，无参的show3()");
}
private String show4(int age){
System.out.println("调用了，私有的，并且有返回值的，int参数的show4(): age = " + age);
return "abcd";
}
}
复制代码测试类：
package fanshe.method;
import java.lang.reflect.Method;
/*
* 获取成员方法并调用：
*
* 1.批量的：
* public Method[] getMethods():获取所有"公有方法"；（包含了父类的方法也包含Object类）
* public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的)
* 2.获取单个的：
* public Method getMethod(String name,Class<?>... parameterTypes):
* 参数：
* name : 方法名；
* Class ... : 形参的Class类型对象
* public Method getDeclaredMethod(String name,Class<?>... parameterTypes)
*
* 调用方法：
* Method --> public Object invoke(Object obj,Object... args):
* 参数说明：
* obj : 要调用方法的对象；
* args:调用方式时所传递的实参；
):
*/
public class MethodClass {
public static void main(String[] args) throws Exception {
//1.获取Class对象
Class stuClass = Class.forName("fanshe.method.Student");
//2.获取所有公有方法
System.out.println("***************获取所有的”公有“方法*******************");
stuClass.getMethods();
Method[] methodArray = stuClass.getMethods();
for(Method m : methodArray){
System.out.println(m);
}
System.out.println("***************获取所有的方法，包括私有的*******************");
methodArray = stuClass.getDeclaredMethods();
for(Method m : methodArray){
System.out.println(m);
}
System.out.println("***************获取公有的show1()方法*******************");
Method m = stuClass.getMethod("show1", String.class);
System.out.println(m);
//实例化一个Student对象
Object obj = stuClass.getConstructor().newInstance();
m.invoke(obj, "刘德华");
System.out.println("***************获取私有的show4()方法******************");
m = stuClass.getDeclaredMethod("show4", int.class);
System.out.println(m);
m.setAccessible(true);//解除私有限定
Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
System.out.println("返回值：" + result);
}
}
复制代码执行结果：
***************获取所有的”公有“方法*******************
public void fanshe.method.Student.show1(java.lang.String)
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
***************获取所有的方法，包括私有的*******************
public void fanshe.method.Student.show1(java.lang.String)
private java.lang.String fanshe.method.Student.show4(int)
protected void fanshe.method.Student.show2()
void fanshe.method.Student.show3()
***************获取公有的show1()方法*******************
public void fanshe.method.Student.show1(java.lang.String)
调用了：公有的，String参数的show1(): s = 刘德华
***************获取私有的show4()方法******************
private java.lang.String fanshe.method.Student.show4(int)
调用了，私有的，并且有返回值的，int参数的show4(): age = 20
返回值：abcd
复制代码由此可见：
m = stuClass.getDeclaredMethod("show4", int.class);//调用制定方法（所有包括私有的），需要传入两个参数，第一个是调用的方法名称，第二个是方法的形参类型，切记是类型。
System.out.println(m); m.setAccessible(true);//解除私有限定 Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参 System.out.println("返回值：" + result);
执行结果：
***************获取所有的”公有“方法*******************
public void fanshe.method.Student.show1(java.lang.String)
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
***************获取所有的方法，包括私有的*******************
public void fanshe.method.Student.show1(java.lang.String)
private java.lang.String fanshe.method.Student.show4(int)
protected void fanshe.method.Student.show2()
void fanshe.method.Student.show3()
***************获取公有的show1()方法*******************
public void fanshe.method.Student.show1(java.lang.String)
调用了：公有的，String参数的show1(): s = 刘德华
***************获取私有的show4()方法******************
private java.lang.String fanshe.method.Student.show4(int)
调用了，私有的，并且有返回值的，int参数的show4(): age = 20
返回值：abcd
复制代码其实这里的成员方法：在模型中有属性一词，就是那些setter（）方法和getter()方法。还有字段组成，这些内容在内省中详解
5、反射main方法
student类：
package fanshe.main;
public class Student {
public static void main(String[] args) {
System.out.println("main方法执行了。。。");
}
}
复制代码测试类：
package fanshe.main;
import java.lang.reflect.Method;
/**
* 获取Student类的main方法、不要与当前的main方法搞混了
*/
public class Main {
public static void main(String[] args) {
try {
//1、获取Student对象的字节码
Class clazz = Class.forName("fanshe.main.Student");
//2、获取main方法
Method methodMain = clazz.getMethod("main", String[].class);//第一个参数：方法名称，第二个参数：方法形参的类型，
//3、调用main方法
// methodMain.invoke(null, new String[]{"a","b","c"});
//第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组，这里要注意在jdk1.4时是数组，jdk1.5之后是可变参数
//这里拆的时候将 new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。
methodMain.invoke(null, (Object)new String[]{"a","b","c"});//方式一
// methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二
} catch (Exception e) {
e.printStackTrace();
}
}
}
复制代码执行结果：
main方法执行了。。。
复制代码6、反射方法的其它使用之---通过反射运行配置文件内容
student类：
public class Student {
public void show(){
System.out.println("is show()");
}
}
复制代码配置文件以txt文件为例子（pro.txt）：
className = cn.fanshe.Student
methodName = show
复制代码测试类：
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Properties;
/*
* 我们利用反射和配置文件，可以使：应用程序更新时，对源码无需进行任何修改
* 我们只需要将新类发送给客户端，并修改配置文件即可
*/
public class Demo {
public static void main(String[] args) throws Exception {
//通过反射获取Class对象
Class stuClass = Class.forName(getValue("className"));//"cn.fanshe.Student"
//2获取show()方法
Method m = stuClass.getMethod(getValue("methodName"));//show
//3.调用show()方法
m.invoke(stuClass.getConstructor().newInstance());
}
//此方法接收一个key，在配置文件中获取相应的value
public static String getValue(String key) throws IOException{
Properties pro = new Properties();//获取配置文件的对象
FileReader in = new FileReader("pro.txt");//获取输入流
pro.load(in);//将流加载到配置文件对象中
in.close();
return pro.getProperty(key);//返回根据key获取的value值
}
}
复制代码执行结果：
is show()
复制代码需求： 当我们升级这个系统时，不要Student类，而需要新写一个Student2的类时，这时只需要更改pro.txt的文件内容就可以了。代码就一点不用改动
要替换的student2类：
public class Student2 {
public void show2(){
System.out.println("is show2()");
}
}
复制代码配置文件更改为：
className = cn.fanshe.Student2
methodName = show2
复制代码执行结果：
is show2();
复制代码7、反射方法的其它使用之---通过反射越过泛型检查
泛型用在编译期，编译过后泛型擦除（消失掉）。所以是可以通过反射越过泛型检查的
测试类：
import java.lang.reflect.Method;
import java.util.ArrayList;
/*
* 通过反射越过泛型检查
*
* 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？
*/
public class Demo {
public static void main(String[] args) throws Exception{
ArrayList<String> strList = new ArrayList<>();
strList.add("aaa");
strList.add("bbb");
// strList.add(100);
//获取ArrayList的Class对象，反向的调用add()方法，添加数据
Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象
//获取add()方法
Method m = listClass.getMethod("add", Object.class);
//调用add()方法
m.invoke(strList, 100);
//遍历集合
for(Object obj : strList){
System.out.println(obj);
}
}
}
复制代码执行结果：
aaa
bbb
100
复制代码注解
注解的概述
Annotation 中文译过来就是注解、标释的意思，在 Java 中注解是一个很重要的知识点，但经常还是有点让新手不容易理解。
我个人认为，比较糟糕的技术文档主要特征之一就是：用专业名词来介绍专业名词。 比如：
Java 注解用于为 Java 代码提供元数据。作为元数据，注解不直接影响你的代码执行，但也有一些类型的注解实际上可以用于这一目的。Java 注解是从 Java5 开始添加到 Java 的。 这是大多数网站上对于 Java 注解，解释确实正确，但是说实在话，我第一次学习的时候，头脑一片空白。这什么跟什么啊？听了像没有听一样。因为概念太过于抽象，所以初学者实在是比较吃力才能够理解，然后随着自己开发过程中不断地强化练习，才会慢慢对它形成正确的认识。
我在写这篇文章的时候，我就在思考。如何让自己或者让读者能够比较直观地认识注解这个概念？是要去官方文档上翻译说明吗？我马上否定了这个答案。
后来，我想到了一样东西————墨水，墨水可以挥发、可以有不同的颜色，用来解释注解正好。
不过，我继续发散思维后，想到了一样东西能够更好地代替墨水，那就是印章。印章可以沾上不同的墨水或者印泥，可以定制印章的文字或者图案，如果愿意它也可以被戳到你任何想戳的物体表面。
但是，我再继续发散思维后，又想到一样东西能够更好地代替印章，那就是标签。标签是一张便利纸，标签上的内容可以自由定义。常见的如货架上的商品价格标签、图书馆中的书本编码标签、实验室中化学材料的名称类别标签等等。
并且，往抽象地说，标签并不一定是一张纸，它可以是对人和事物的属性评价。也就是说，标签具备对于抽象事物的解释。
所以，基于如此，我完成了自我的知识认知升级，我决定用标签来解释注解。
注解如同标签
之前某新闻客户端的评论有盖楼的习惯，于是 “乔布斯重新定义了手机、罗永浩重新定义了傻X” 就经常极为工整地出现在了评论楼层中，并且广大网友在相当长的一段时间内对于这种行为乐此不疲。这其实就是等同于贴标签的行为。 在某些网友眼中，罗永浩就成了傻X的代名词。
广大网友给罗永浩贴了一个名为“傻x”的标签，他们并不真正了解罗永浩，不知道他当教师、砸冰箱、办博客的壮举，但是因为“傻x”这样的标签存在，这有助于他们直接快速地对罗永浩这个人做出评价，然后基于此，罗永浩就可以成为茶余饭后的谈资，这就是标签的力量。
而在网络的另一边，老罗靠他的人格魅力自然收获一大批忠实的拥泵，他们对于老罗贴的又是另一种标签。
我无意于评价这两种行为，我再引个例子。
《奇葩说》是近年网络上非常火热的辩论节目，其中辩手陈铭被另外一个辩手马薇薇攻击说是————“站在宇宙中心呼唤爱”，然后贴上了一个大大的标签————“鸡汤男”，自此以后，观众再看到陈铭的时候，首先映入脑海中便是“鸡汤男”三个大字，其实本身而言陈铭非常优秀，为人师表、作风正派、谈吐举止得体，但是在网络中，因为娱乐至上的环境所致，人们更愿意以娱乐的心态来认知一切，于是“鸡汤男”就如陈铭自己所说成了一个撕不了的标签。
我们可以抽象概括一下，标签是对事物行为的某些角度的评价与解释。
到这里，终于可以引出本文的主角注解了。
初学者可以这样理解注解：想像代码具有生命，注解就是对于代码中某些鲜活个体的贴上去的一张标签。简化来讲，注解如同一张标签。
在未开始学习任何注解具体语法而言，你可以把注解看成一张标签。这有助于你快速地理解它的大致作用。如果初学者在学习过程有大脑放空的时候，请不要慌张，对自己说：
注解，标签。注解，标签。
注解的语法
因为平常开发少见，相信有不少的人员会认为注解的地位不高。其实同 classs 和 interface 一样，注解也属于一种类型。它是在 Java SE 5.0 版本中开始引入的概念。
注解的定义
注解通过 @interface 关键字进行定义。
public @interface TestAnnotation {
}
复制代码它的形式跟接口很类似，不过前面多了一个 @ 符号。上面的代码就创建了一个名字为 TestAnnotaion 的注解。
你可以简单理解为创建了一张名字为 TestAnnotation 的标签。
注解的应用
上面创建了一个注解，那么注解的的使用方法是什么呢。
@TestAnnotation
public class Test {
}
复制代码创建一个类 Test,然后在类定义的地方加上 @TestAnnotation 就可以用 TestAnnotation 注解这个类了。
你可以简单理解为将 TestAnnotation 这张标签贴到 Test 这个类上面。
不过，要想注解能够正常工作，还需要介绍一下一个新的概念那就是元注解。
元注解
元注解是什么意思呢？
元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面。
如果难于理解的话，你可以这样理解。元注解也是一张标签，但是它是一张特殊的标签，它的作用和目的就是给其他普通的标签进行解释说明的。
元标签有 @Retention、@Documented、@Target、@Inherited、@Repeatable 5 种。
@Retention
Retention 的英文意为保留期的意思。当 @Retention 应用到一个注解上的时候，它解释说明了这个注解的的存活时间。
它的取值如下：
- RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时它将被丢弃忽视。
- RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加载到 JVM 中。
- RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载进入到 JVM 中，所以在程序运行时可以获取到它们。
我们可以这样的方式来加深理解，@Retention 去给一张标签解释的时候，它指定了这张标签张贴的时间。@Retention 相当于给一张标签上面盖了一张时间戳，时间戳指明了标签张贴的时间周期。
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
}
复制代码@Documented
顾名思义，这个元注解肯定是和文档有关。它的作用是能够将注解中的元素包含到 Javadoc 中去。
@Target
Target 是目标的意思，@Target 指定了注解运用的地方。
你可以这样理解，当一个注解被 @Target 注解时，这个注解就被限定了运用的场景。
类比到标签，原本标签是你想张贴到哪个地方就到哪个地方，但是因为 @Target 的存在，它张贴的地方就非常具体了，比如只能张贴到方法上、类上、方法参数上等等。@Target 有下面的取值
- ElementType.ANNOTATION_TYPE 可以给一个注解进行注解
- ElementType.CONSTRUCTOR 可以给构造方法进行注解
- ElementType.FIELD 可以给属性进行注解
- ElementType.LOCAL_VARIABLE 可以给局部变量进行注解
- ElementType.METHOD 可以给方法进行注解
- ElementType.PACKAGE 可以给一个包进行注解
- ElementType.PARAMETER 可以给一个方法内的参数进行注解
- ElementType.TYPE 可以给一个类型进行注解，比如类、接口、枚举
@Inherited
Inherited 是继承的意思，但是它并不是说注解本身可以继承，而是说如果一个超类被 @Inherited 注解过的注解进行注解的话，那么如果它的子类没有被任何注解应用的话，那么这个子类就继承了超类的注解。 说的比较抽象。代码来解释。
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@interface Test {}
@Test
public class A {}
public class B extends A {}
复制代码解 Test 被 @Inherited 修饰，之后类 A 被 Test 注解，类 B 继承 A,类 B 也拥有 Test 这个注解。
可以这样理解：
老子非常有钱，所以人们给他贴了一张标签叫做富豪。
老子的儿子长大后，只要没有和老子断绝父子关系，虽然别人没有给他贴标签，但是他自然也是富豪。
老子的孙子长大了，自然也是富豪。
这就是人们口中戏称的富一代，富二代，富三代。虽然叫法不同，好像好多个标签，但其实事情的本质也就是他们有一张共同的标签，也就是老子身上的那张富豪的标签。
@Repeatable
Repeatable 自然是可重复的意思。@Repeatable 是 Java 1.8 才加进来的，所以算是一个新的特性。
什么样的注解会多次应用呢？通常是注解的值可以同时取多个。
举个例子，一个人他既是程序员又是产品经理,同时他还是个画家。
@interface Persons {
Person[] value();
}
@Repeatable(Persons.class)
@interface Person{
String role default "";
}
@Person(role="artist")
@Person(role="coder")
@Person(role="PM")
public class SuperMan{
}
复制代码注意上面的代码，@Repeatable 注解了 Person。而 @Repeatable 后面括号中的类相当于一个容器注解。
什么是容器注解呢？
就是用来存放其它注解的地方。它本身也是一个注解。
我们再看看代码中的相关容器注解。
@interface Persons {
Person[] value();
}
复制代码按照规定，它里面必须要有一个 value 的属性，属性类型是一个被 @Repeatable 注解过的注解数组，注意它是数组。
如果不好理解的话，可以这样理解。Persons 是一张总的标签，上面贴满了 Person 这种同类型但内容不一样的标签。把 Persons 给一个 SuperMan 贴上，相当于同时给他贴了程序员、产品经理、画家的标签。
我们可能对于 @Person(role=”PM”) 括号里面的内容感兴趣，它其实就是给 Person 这个注解的 role 属性赋值为 PM ，大家不明白正常，马上就讲到注解的属性这一块。
注解的属性
注解的属性也叫做成员变量。注解只有成员变量，没有方法。注解的成员变量在注解的定义中以“无形参的方法”形式来声明，其方法名定义了该成员变量的名字，其返回值定义了该成员变量的类型。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
int id();
String msg();
}
复制代码上面代码定义了 TestAnnotation 这个注解中拥有 id 和 msg 两个属性。在使用的时候，我们应该给它们进行赋值。
赋值的方式是在注解的括号内以 value=”” 形式，多个属性之前用 ，隔开。
@TestAnnotation(id=3,msg="hello annotation")
public class Test {
}
复制代码需要注意的是，在注解中定义属性时它的类型必须是 8 种基本数据类型外加 类、接口、注解及它们的数组。
注解中属性可以有默认值，默认值需要用 default 关键值指定。比如：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
public int id() default -1;
public String msg() default "Hi";
}
复制代码TestAnnotation 中 id 属性默认值为 -1，msg 属性默认值为 Hi。 它可以这样应用。
@TestAnnotation()
public class Test {}
复制代码因为有默认值，所以无需要再在 @TestAnnotation 后面的括号里面进行赋值了，这一步可以省略。
另外，还有一种情况。如果一个注解内仅仅只有一个名字为 value 的属性时，应用这个注解时可以直接接属性值填写到括号内。
public @interface Check {
String value();
}
复制代码上面代码中，Check 这个注解只有 value 这个属性。所以可以这样应用。
@Check("hi")
int a;
复制代码和这下面的效果是一样的
@Check(value="hi")
int a;
复制代码最后，还需要注意的一种情况是一个注解没有任何属性。比如
public @interface Perform {}
复制代码那么在应用这个注解的时候，括号都可以省略。
@Perform
public void testMethod(){}
复制代码Java 预置的注解
学习了上面相关的知识，我们已经可以自己定义一个注解了。其实 Java 语言本身已经提供了几个现成的注解。
@Deprecated
这个元素是用来标记过时的元素，想必大家在日常开发中经常碰到。编译器在编译阶段遇到这个注解时会发出提醒警告，告诉开发者正在调用一个过时的元素比如过时的方法、过时的类、过时的成员变量。
public class Hero {
@Deprecated
public void say(){
System.out.println("Noting has to say!");
}
public void speak(){
System.out.println("I have a dream!");
}
}
复制代码定义了一个 Hero 类，它有两个方法 say() 和 speak() ，其中 say() 被 @Deprecated 注解。然后我们在 IDE 中分别调用它们。
可以看到，say() 方法上面被一条直线划了一条，这其实就是编译器识别后的提醒效果。
@Override
这个大家应该很熟悉了，提示子类要复写父类中被 @Override 修饰的方法
@SuppressWarnings
阻止警告的意思。之前说过调用被 @Deprecated 注解的方法后，编译器会警告提醒，而有时候开发者会忽略这种警告，他们可以在调用的地方通过 @SuppressWarnings 达到目的。
@SuppressWarnings("deprecation")
public void test1(){
Hero hero = new Hero();
hero.say();
hero.speak();
}
复制代码@SafeVarargs
参数安全类型注解。它的目的是提醒开发者不要用参数做一些不安全的操作,它的存在会阻止编译器产生 unchecked 这样的警告。它是在 Java 1.7 的版本中加入的。
@SafeVarargs // Not actually safe!
static void m(List<String>... stringLists) {
Object[] array = stringLists;
List<Integer> tmpList = Arrays.asList(42);
array[0] = tmpList; // Semantically invalid, but compiles without warnings
String s = stringLists[0].get(0); // Oh no, ClassCastException at runtime!
}
复制代码上面的代码中，编译阶段不会报错，但是运行时会抛出 ClassCastException 这个异常，所以它虽然告诉开发者要妥善处理，但是开发者自己还是搞砸了。
Java 官方文档说，未来的版本会授权编译器对这种不安全的操作产生错误警告。
@FunctionalInterface
函数式接口注解，这个是 Java 1.8 版本引入的新特性。函数式编程很火，所以 Java 8 也及时添加了这个特性。
函数式接口 (Functional Interface) 就是一个具有一个方法的普通接口。 比如
@FunctionalInterface
public interface Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}
复制代码我们进行线程开发中常用的 Runnable 就是一个典型的函数式接口，上面源码可以看到它就被 @FunctionalInterface 注解。
可能有人会疑惑，函数式接口标记有什么用，这个原因是函数式接口可以很容易转换为 Lambda 表达式。这是另外的主题了，有兴趣的同学请自己搜索相关知识点学习。
注解的提取
博文前面的部分讲了注解的基本语法，现在是时候检测我们所学的内容了。
我通过用标签来比作注解，前面的内容是讲怎么写注解，然后贴到哪个地方去，而现在我们要做的工作就是检阅这些标签内容。 形象的比喻就是你把这些注解标签在合适的时候撕下来，然后检阅上面的内容信息。
要想正确检阅注解，离不开一个手段，那就是反射。
注解与反射
注解通过反射获取。首先可以通过 Class 对象的 isAnnotationPresent() 方法判断它是否应用了某个注解
public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {}
复制代码然后通过 getAnnotation() 方法来获取 Annotation 对象。
public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {}
复制代码或者是 getAnnotations() 方法。
public Annotation[] getAnnotations() {}
复制代码前一种方法返回指定类型的注解，后一种方法返回注解到这个元素上的所有注解。
如果获取到的 Annotation 如果不为 null，则就可以调用它们的属性方法了。比如
@TestAnnotation()
public class Test {
public static void main(String[] args) {
boolean hasAnnotation = Test.class.isAnnotationPresent(TestAnnotation.class);
if ( hasAnnotation ) {
TestAnnotation testAnnotation = Test.class.getAnnotation(TestAnnotation.class);
System.out.println("id:"+testAnnotation.id());
System.out.println("msg:"+testAnnotation.msg());
}
}
}
复制代码执行结果：
id:-1
msg:
复制代码这个正是 TestAnnotation 中 id 和 msg 的默认值。
上面的例子中，只是检阅出了注解在类上的注解，其实属性、方法上的注解照样是可以的。同样还是要假手于反射。
@TestAnnotation(msg="hello")
public class Test {
@Check(value="hi")
int a;
@Perform
public void testMethod(){}
@SuppressWarnings("deprecation")
public void test1(){
Hero hero = new Hero();
hero.say();
hero.speak();
}
public static void main(String[] args) {
boolean hasAnnotation = Test.class.isAnnotationPresent(TestAnnotation.class);
if ( hasAnnotation ) {
TestAnnotation testAnnotation = Test.class.getAnnotation(TestAnnotation.class);
//获取类的注解
System.out.println("id:"+testAnnotation.id());
System.out.println("msg:"+testAnnotation.msg());
}
try {
Field a = Test.class.getDeclaredField("a");
a.setAccessible(true);
//获取一个成员变量上的注解
Check check = a.getAnnotation(Check.class);
if ( check != null ) {
System.out.println("check value:"+check.value());
}
Method testMethod = Test.class.getDeclaredMethod("testMethod");
if ( testMethod != null ) {
// 获取方法中的注解
Annotation[] ans = testMethod.getAnnotations();
for( int i = 0;i < ans.length;i++) {
System.out.println("method testMethod annotation:"+ans[i].annotationType().getSimpleName());
}
}
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println(e.getMessage());
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println(e.getMessage());
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println(e.getMessage());
}
}
}
复制代码执行结果：
id:-1
msg:hello
check value:hi
method testMethod annotation:Perform
复制代码需要注意的是，如果一个注解要在运行时被成功提取，那么 @Retention(RetentionPolicy.RUNTIME) 是必须的。
注解的使用场景
我相信博文讲到这里大家都很熟悉了注解，但是有不少同学肯定会问，注解到底有什么用呢？
对啊注解到底有什么用？
我们不妨将目光放到 Java 官方文档上来。
文章开始的时候，我用标签来类比注解。但标签比喻只是我的手段，而不是目的。为的是让大家在初次学习注解时能够不被那些抽象的新概念搞懵。既然现在，我们已经对注解有所了解，我们不妨再仔细阅读官方最严谨的文档。
注解是一系列元数据，它提供数据用来解释程序代码，但是注解并非是所解释的代码本身的一部分。注解对于代码的运行效果没有直接影响。
注解有许多用处，主要如下：
- 提供信息给编译器： 编译器可以利用注解来探测错误和警告信息
- 编译阶段时的处理： 软件工具可以用来利用注解信息来生成代码、Html文档或者做其它相应处理。
- 运行时的处理： 某些注解可以在程序运行的时候接受代码的提取 值得注意的是，注解不是代码本身的一部分。
如果难于理解，可以这样看。罗永浩还是罗永浩，不会因为某些人对于他“傻x”的评价而改变，标签只是某些人对于其他事物的评价，但是标签不会改变事物本身，标签只是特定人群的手段。所以，注解同样无法改变代码本身，注解只是某些工具的的工具。
还是回到官方文档的解释上，注解主要针对的是编译器和其它工具软件(SoftWare tool)。
当开发者使用了Annotation 修饰了类、方法、Field 等成员之后，这些 Annotation 不会自己生效，必须由开发者提供相应的代码来提取并处理 Annotation 信息。这些处理提取和处理 Annotation 的代码统称为 APT（Annotation Processing Tool)。
现在，我们可以给自己答案了，注解有什么用？给谁用？给 编译器或者 APT 用的。
如果，你还是没有搞清楚的话，我亲自写一个好了。
亲手自定义注解完成某个目的
我要写一个测试框架，测试程序员的代码有无明显的异常。
—— 程序员 A : 我写了一个类，它的名字叫做 NoBug，因为它所有的方法都没有错误。 —— 我：自信是好事，不过为了防止意外，让我测试一下如何？ —— 程序员 A: 怎么测试？ —— 我：把你写的代码的方法都加上 @Jiecha 这个注解就好了。 —— 程序员 A: 好的。
package ceshi;
import ceshi.Jiecha;
public class NoBug {
@Jiecha
public void suanShu(){
System.out.println("1234567890");
}
@Jiecha
public void jiafa(){
System.out.println("1+1="+1+1);
}
@Jiecha
public void jiefa(){
System.out.println("1-1="+(1-1));
}
@Jiecha
public void chengfa(){
System.out.println("3 x 5="+ 3*5);
}
@Jiecha
public void chufa(){
System.out.println("6 / 0="+ 6 / 0);
}
public void ziwojieshao(){
System.out.println("我写的程序没有 bug!");
}
}
复制代码上面的代码，有些方法上面运用了 @Jiecha 注解。
这个注解是我写的测试软件框架中定义的注解。
package ceshi;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME)
public @interface Jiecha {
}
复制代码然后，我再编写一个测试类 TestTool 就可以测试 NoBug 相应的方法了。
package ceshi;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TestTool {
public static void main(String[] args) {
// TODO Auto-generated method stub
NoBug testobj = new NoBug();
Class clazz = testobj.getClass();
Method[] method = clazz.getDeclaredMethods();
//用来记录测试产生的 log 信息
StringBuilder log = new StringBuilder();
// 记录异常的次数
int errornum = 0;
for ( Method m: method ) {
// 只有被 @Jiecha 标注过的方法才进行测试
if ( m.isAnnotationPresent( Jiecha.class )) {
try {
m.setAccessible(true);
m.invoke(testobj, null);
} catch (Exception e) {
// TODO Auto-generated catch block
//e.printStackTrace();
errornum++;
log.append(m.getName());
log.append(" ");
log.append("has error:");
log.append("\n\r caused by ");
//记录测试过程中，发生的异常的名称
log.append(e.getCause().getClass().getSimpleName());
log.append("\n\r");
//记录测试过程中，发生的异常的具体信息
log.append(e.getCause().getMessage());
log.append("\n\r");
}
}
}
log.append(clazz.getSimpleName());
log.append(" has ");
log.append(errornum);
log.append(" error.");
// 生成测试报告
System.out.println(log.toString());
}
}
复制代码执行结果：
1234567890
1+1=11
1-1=0
3 x 5=15
chufa has error:
caused by ArithmeticException
/ by zero
NoBug has 1 error.
复制代码提示 NoBug 类中的 chufa() 这个方法有异常，这个异常名称叫做 ArithmeticException，原因是运算过程中进行了除 0 的操作。
所以，NoBug 这个类有 Bug。
这样，通过注解我完成了我自己的目的，那就是对别人的代码进行测试。
所以，再问我注解什么时候用？我只能告诉你，这取决于你想利用它干什么用。
注解应用实例
注解运用的地方太多了，如： JUnit 这个是一个测试框架，典型使用方法如下：
public class ExampleUnitTest {
@Test
public void addition_isCorrect() throws Exception {
assertEquals(4, 2 + 2);
}
}
复制代码@Test 标记了要进行测试的方法 addition_isCorrect().
还有例如ssm框架等运用了大量的注解。
JavaSE阶段就告一段落了，希望这个Java基础笔记能让更多的人深刻理解Java基础，并且快速入门！祝大家前程似锦！