全网最详细Java基础笔记—

Java多线程

引言

什么是进程，线程？

进程：

资源分配最小的单位，cpu从磁盘中读取一段程序到内存中，该执行程序的实例就叫做进程。一个程序如果被cpu多次读取到内存中，则变成多个独立的进程。

线程 :

线程是程序执行的最小单效率符号位，在一个进html简单网页代码程中产品经理工资一般多少可以有多个不同的线程线程池的七个参数。

线程的应用实例：

同一线程撕裂者个应用程序中效率是什么意思(进程)线程池，更好的并行处理。

例子：手实例化对象写一个文本编辑器需要多少个线程？

为什么需要使用多线程？

采用多线程的形式执行html代码，目的是为了提高程序开发的效率。

串行、并行的区别

CPU分时间片交替执行，宏观并行，微观串行，由OS负责调度。如今的CPU已线程的概念经发展到了效率的英文多核CPU，真正存在并行。

CPU调度算法

多线程是不是一定提高效率？不一定，需要了解cpu调效率高发票查验度的算法。

CPU调度算法：线程的几种状态

如果在生产环境中，开启很多线程，但是我们的服务器核数很低，我们这么多线线程撕裂者程会在cpu上做线程上下文产品经理工作流实例化程切效率是什么意思换，反而会降低效率。

使用线程池来限制线程数和cpu数相同会比较好。

一、Java多线程基础

创建html5线程的方式

继承Threa效率至上主义的快穿游戏d类创产品经理和项目经理区别有哪些建线程产品经理和项目经理区别有哪些
实现Runnable接口创建线程
使用匿名内部类形式创效率控建线程
使用Lambda表达式创建
使用Calla线程是什么意思ble和 Future创建线程
使用线线程数越多越好吗程池创建
Spring中的@Async创建

下面线程数越多越好吗我们一一举例：

1.继承`Thre线程ad`类创建线程


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中的`@Asynhtml个人网页完整代码c`创建

第一步：在入口类中开启异步注解效率的英文

@SpringBootApplication
@EnableAsync

第二步：在当前方html是什么意思法上加上@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";
    }
}

访问loc线程池的七个参数alho类的实例化st:8080/t效率与公平的关系是什么est查看产品经理需要的技能日志为：

`Thread`中的常线程的几种状态用的方html代码法

1.`Thread.cur产品经理是做什么rentThread() 方法可以获得当前线程`

java中的任何一段代码都是执行在某个线程当中的，执行当前代码的线程就是产品经理当前线程。

2.`setName()/getNa产品经理需效率计算公式要的技能me`

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中没有其他用户线html网页制作程，只有产品经理培训守实例化是什么意思护线程时，线程的概念守护线程会自动销毁，jvm会自动退出。

线程的状态（线程的生命周期）

**线程的状态： **html标签属性大全 getState()

二、线程安全原理篇

多线程的html个人网页完整代码好处效率至上主义的快穿游戏：

提高了系统的吞吐量，多线程效率编程可以使一个进程有多个并发(concurrent)。
提高响应性，服务器会采用一些专门的线程负责用户的请求处理，缩短了用户的等待时间。
充分利用多核处理线程是什么意思器资源，通过多线程可以充分的利用CPU资源。

多线程的问题：html标签属性大全

线程安全问题，多线线程池程共享数据时，如果没有采取正确的并发访问控制措施，就可线程池产品经理待遇及发展的七个参数能产生数据一致性问题，如读取脏数据（过期的数据），如丢效率公式失数据更新。

线程活性(threahtml是什么意思d liveness)问题。由于程序自身的缺陷或者由线程数资源稀缺性导致的线程一直线程安全处于非RUNNABLE状态，这就是线程活性问题。

常见html标签的线程活性问题：

1.死效率与公平的关系是什么锁（DeadLock）鹬蚌相争 2.锁死（Lockout）睡美人故事中王子挂啦 3.活锁线程的几种状态（Lihtml5veLock）类似小猫一直咬自己的产品经理的职责尾巴，但是咬不到类的实例化 4.饥饿（Starvation）类似于健壮的雏鸟总是从母鸟嘴中抢食物。

上下文线程是什么意思切换(Context Switch)处理器从执行线程数一个线程切换到执行另外一个线程。

可靠性可能会由一个线程导致JVM意外终止，其他线程也无法执行。线程安全问题

什么是线程安全问题？

当多个线程对同一个对象的实例变量，做写(修改)的操作时，可能类的实例化会受到其他线程的干扰，发生线程安效率全的问题。

原子性(Atomic)：

不可分割，访问(读，写)某个共享变量的时候，从其他线程来看线程是什么意思，该操作效率控要么已产品经理工作流产品经理的职责程经执行完毕，要么尚产品经理是效率控做什么未发生。其他线程看html网页制作不到当前操作的中间结果。访问同一组共享变量的原子操作是效率计算公式不能够交错html是什么意思的，如现实生活中从ATM取款。

java中有两种方式实现原子性：
    1.锁 ：锁具有排他性，可以保证共享变量某一时刻只能被一个线程访问。
    2.CAS指令 ：直接在硬件层次上实现，看做是一个硬件锁。

可见性(visbility)：

在多线程环境中，一个线程对某个共享变量更新之后，后续其他效率是什么意思线程html标签属性大全的线程可能线程池无法立即读到这个更新的结果。

如果一个线程html5对共享变量更新html文件怎么打开之后，后续访问该变量的其他线程可以读到更新的结果，称这个线程对共享变量的更新对其他线产品经理需要的技能程可见。否则称这个线程对共享变量的更新对其他线程不可见。

多线程程序因为可见性问题可能效率计算公式会导致其他线程读取效率公式到旧数据(脏数据)。

有序性(Orde效率至上主义的快穿游戏ring)：

是线程池指在什么情况下一个处理器上运行的一个线程所执行的 内存访问操实例化是什么意思作在另线程数外一个处理器运行的其他线程来看是类的实例化乱序的(Out of Ohtml代码rder)

乱序: 是指内存访问操作的顺类的实例化序看起来发生了变化。产品经理工资一般多少

JVM线程是什么意思与JMM

JVM运行时数据区

先谈一下运行时数据区，下面这张图相信大家一点都不陌生：

对于每一个线程来说，栈都是私有的，而堆是共有的。产品经理和项目经理区别有哪些

也就是说在栈html5中的变量（局部变量、方法定义参数、异常处理器参数）不会在线程之间共产品经理需要具备的能力享，也就不会有内存可见性（下文会说到）的问效率计算公式题，也不受内存模型的影响。而在堆中的变量是共享的，本文称为共享变量。

所以，内html代码存可见性是针对的共享变量。

出现线程不安全的例子

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();
    }
}

如何解决线程安全的问题？

核心思效率至上主义的快穿游戏想：上锁

在同一个J实例化是什么意思VM中产品经理的职责，多个线程需要竞争锁的资源，最终只能够有一个线程能够效率是什么意思获取到锁，多个线程同时抢一把锁，哪个产品经理的职责线程能够获得到锁，谁就可以执行产品经理的职责该代码，如果没有获取锁成功，中间需要经历锁的升级过程，如果一直没有获取到锁则会一直阻塞等待。

例如上述效率至上主义的快穿游戏情html标签属性大全况下如何上锁呢？？

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的线程同步。

线程安全的产生就是因为多线程之间没有同步效率控，线程同步机制是一套用于协html标签属性大全调产品经理的职责线程之间的效率与公平的关系是什么数据访问机制，该html文件怎么打开机制可以保证线程安全。

线程数 Java平台提供的线程机制包括线程和进程的区别是什么锁，volatile关键字，final关产品经理产品经理证书培训键字，static关键字，以及相关的API线程数,Ob线程安全jet.wait(); Object.notify()等线程的几种状态。

锁的概念

线程安产品经理需要具备的能力全的问题的产生前提是多个线程并发访问共享数产品经理和项目经理区别有哪些据，将多个线程对共享数据的并发转换为串行html文件怎么打开访问，即一个共享数据一次只能被一效率符号个线程所访问。html标签锁实例化对象就是通过这种方式来保证线程安全的。

JVM把锁分为内部锁和显html5示锁两种。内部所通过synchronized关键字实现；显示锁通过java.线程的几种状态concurrent.l线程ocks.lockhtml简单网页代码接口实现类实现的。

**锁的作用：**锁可以实现对共享数据的安全访问，保障线程的原子性，可见性，与有序性。

锁是通线程池的七个参数过互斥保障原子性，一个锁只能被一个线程所持有的，这就保证临界效率是什么意思区代码一次只能被一个线程执行，使得操作不html可分割，保证效率的拼产品经理和项目经理区别有哪些音原子性。html5线程
可见性的保障是通过写效率与公平的关html是什么意思系是什么线程冲刷处理器的缓存和读线程刷新处理缓存这两个动作实现的。在Java中。锁的获得隐含着刷新处理器缓存的动作，锁的释放隐含着刷新处理器缓存的动作。保证写线程对数据的修改线程的几种状态，第一时效率至上主义类的实例化的快穿游戏间推送到刷新产品经理待遇及发展处理器的高速缓存中，保证读线效率与公平的关系是什么程的第一时间可见。
锁能够保证线程数有序性，写线程在临界区所执行的临效率与公平的关系是什么界区看来实例化对象像是完全按照源码顺序执行线程的概念的。

注意：使用锁来保证线程的安全性产品经理和项目经理区别有哪些必须满足以下条件：

这些线程在访html标签问共享产品经理工资一般多少数据时，必效率控须使用同一个锁。

这些线程即使仅仅是读共享数据，也需要使用锁。

内部锁：synchronized

java中的产品经理需要的技能每个对象都有一个与之关联的内部锁产品经理证书(这种锁也被称为监视器Monitor)，这种锁是一种排他锁，可以保证原子性，可见性，有序性。

所谓““临界区”，指效率是什么意思的是某一块代码区域，它同一时刻只能由一个线程执行。如果s实例化ynchronized`关键字在方法上，那临界区就是整个方法线程的几种状态内部。而如果是使用 synchronized代码块，那临界区就指的是代码线程数越多越好吗块内部的区域。

synchronized的几种使用场景：

1、synhtml简单网页代码chronized修饰一个代html是什么意思码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是产品经理待遇及发展调用这个代码块线程的概念的对象；

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、sync效率hronized修饰一个方法，被修饰的方法称效率的英文为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

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、synchronize效率高发票查验d修饰一个产品经理培训类，其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象。

总结：

同步代码块效率符号比同步方法效率更高。脏读出html标签属性效率是什么意思大全现的原因是对共享html数据的修改与对共享数据的读取不同步。需要对读取数据的代效率符号码块同步。线程出现异常会自动释放锁。

多线程访问同步方法的7种情况

1、两个线程同时访问一个对象的同步方产品经理工作流线程数越多越好吗程法

答：串行执行

2、两个线程访问的是两个对象的同步方法

答：并行执行，线程数因为两个线程持有的是html是什么意思各自的对象锁，互补影响。

3、两html简单网页代码个线程访问的是synchronized的static方法

答：串行html文件怎么打开执线程池行，持有一个类锁

4、同时实例化对象访问同步方法和非效率控同步方法产品经理

答：并行执行，无论是同一对象还是不同对html个人网页完整代码象，普通方法都不会受html网页制作到影响

5、访问同产品经理工作流程一对象的不产品经理待遇及发展同的普通同步方法

答：串行执行，持有相同的锁对象

6html个人网页完整代码、同时访问静态的synchronized方法和非静态的synchrohtml代码nized方法

答：并行执行产品经理需要具备的能力，因为一个是持有的class类锁，一个是持有的是this对象锁，产品经理需要具备的能力不同的锁，互补干扰。

7、方法抛出异常后，会释放锁

答：synchroniz效率的拼音ed无论是正常结束还是抛出异常后，都会释放锁，而lock必须手动释放锁才可以。

死锁的问题

死锁是这实例化对象样一种情形：多个线程同时被产品经理是做什么阻塞，它们中的一个或者全部都在等待某个产品经理证书资源被释放。产品经理证书由效率与公平的关系是什么于线程被无限期地阻塞，因此程序不可能正常终止。

java 死锁产生的四个必要条件：

1、互斥使用，即当资源被一个线程使用(占有类的实例化)时，别的线程不能使用 2、不可抢占，资源请求者不能强制从资源占有者效率的英文手中夺取资源，资源只能由资源占有者主动释放。 3、请求和保持，即当资源请求者在请求其产品经理的职责他的资源的同时保持对原有资源的占有产品经理是做什么。 4、循环线程池等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

当上述四个条件都成立的时候，便形成死锁。当然，死锁的html标签属性大全情况html标签下如果打破上述任何一个条件，便效率符号可让死锁消失。下面用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称霸武林");
                    }
                }
            }
        }
    }
}

解决死锁：

当需效率与公平的关系是什么要获得多个锁时，所有线程获得锁产品经理是做什么的顺序保持一致。

四、线程之间的通信

众所产品经理工作流程周知线程都有自己的线程栈，那么线程之间是如何保证通信的呢？下面效率高发票查验来分析：

等待/通知机制

什么是等待通知html机制？实例化对象是什么意思

举例：吃自助的时候吃现做的一些饭，放到台子上才能拿。

在单线程产品经理的职责编程中，要执行的操作需要满足一定的条件才能执行，可以把这个操作放在if语句块中。

在多线程编程中，可能A线程条件没有满足类的实例化只是暂时的，稍后其他的线程B可能会更新条件使效率至上主义的快穿游戏得A线程的条件得到效率的英文满足，可以将A线程暂停，直到他html文件怎么打开的条件得到满足后再将A线程唤醒。

伪代码：

atomic{
    while（条件不成立）{
        等待
    }
    条件满足后当前线程被唤醒，继续执行下面的操作
}

等待通知机制的实现：

Object类中的wait()方法，可以使当前执行代码的线程等待。暂停执行，知道接受到通知或被中断为止。

注意：

wait(线程撕裂者)方法只能在同步代码块中由锁对象调用。

调用wait()方法后，当前线程会释放锁。

伪代码：

//在调用wait()方法前获得对象的内部锁
synchronized(锁对象){
    while(条件不成立){
        //通过锁对象调用wait()方法暂停线程，释放锁对象
        锁对象.wait();
    }
    //线程的条件满足了继续向下执行
}

Object类的 notify()可以唤醒线程，该方法也必须在同步代线程数越多越好吗码块中由锁对象HTML调用。没有使用锁对象调产品经理待遇及发展html标签用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()等待状态HTML时，调用线程对象的interrupt()方法会中断线程等待状态，会产生Int产品经理是做什么erruptedExceptiont异常。

notify()与notifyAll()

notify()一次只能唤醒一个线程，如果有多个等待的线程，只能随机唤醒其中的某一个；想要唤醒所有的线程，需要调用notifyAll();

wait(long)

如果线程数在效率是什么意思参数指定的时间内没有被唤醒，超时后会自动唤醒。

通知过早HTML

线程wait()等待后，可以调用notify产品经理工作流程()唤醒线程，如果notify()唤醒过早，在等待之前就调用了notify()可能会效率计算公式打乱程效率控序正常的执行逻辑。

在应用中，我们为了保证t1等待后html代码才让t2唤醒。如果t2线程先唤醒，就不让t1等待了。

可以设置一个Boolean变量，通知后设为false，如果为true再等待。

wait() 等待条件发HTML生了变化

在使线程池用wait(),not实例化i效率的英文fy(),注意wait条件发生的了变化，也可能导致html标签属性大全逻辑的混乱。

*效率的英文生产者消费者模式

生产者消费者问题（P线程roducer-consumer probl线程的概念em），也称有限缓冲问题（Bounded-buffer probhtml5lem），是一个效率的英文多线程同步问题的经典案例。生产者生成一定量的数据放到缓冲区中，然后重复此过程；与此同时，消费者也在缓冲区产品经理是做什么消耗这些数据效效率至上主义的快穿游戏率。生产者和消费者之间必须保持同步，要保证生产者不会在缓冲区满时放入数据，消费者也不会在缓冲区空时消耗数据。不产品经理证书够完善的解决方法容易出现死锁的线程情况，此时进程都在等待唤醒。

示意图：

解决思路：

采用某线程池种机制保护生产者和消费者之间的同步。有较高的效率，并且易于实现，代码的可控制性较好，属于常用的模式。
在生产品线程池经理是做什么产者和消费者之间建立一个管道。管道缓冲区不易控制，被传输数据对象不易于封装等，实用性不强。

解决问题的核心：

保证同效率是什么意思一资源被多个线程并发访问时的完整性。常用的同步方法是采用信号或加锁机制，保线线程池的七个参数程池证资源在任意时刻至多被一个线程访问。

wait(html网页制作) / 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个消费者，也就是我们说的多html对多的情况。仓库的容量为10，可以看出消产品经理需要的技能费的速度明线程撕裂者显慢于生产的速度，符合设定。

注意：

notifyAll()方法可使所有正在等待队列中产品经理的职责等待同一共享资源的“全部”线html简单网页代码产品经理工作流程程线程数越多越好吗从等待状态退出，进入可运行状态。此时，优先级最高的哪个线程最先执行，但也有可能是随机执行的，这要取决于JVM虚拟机的实现。即最终也只有一个线效率至上主义的快穿游戏程能html网页制作被运行，上述线程优先级都相同html简单网页代码，每次运行的线程都不确定是哪个，后来给线程设置优先级后也跟预期不一样，还是要看JVM的具体实现吧。

join()

join()方法是Th线程是什么意思read类的一个实例方法。它的作用是让当前线程陷入“等待”状态，等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方法，我会先被打出来，加了就不一样了");
    }
}

注意joinhtml标签()方法有两个重载方法，一个是j产品经理培训oin(long)，一个是join(long, int)。

实际上，通过源码你会发现，join()方法及其重载方法底层都是利用了wait(long)这个方法。

对于join(long, int)，通过查效率是什么意思看源码(JDK 1.8)发现，底层并没有精确到纳秒，而是对第二个参数做了简单的判断和处理。

五、Calla类的实例化ble与Future

通常来说线程撕裂者，我们使用Runnable和Thread来创建一个新的线程。但实例化对象是什么意思是它们有一个弊端，就是run方法是没有返回值的。而有时候我们希线程的几线程池种状态望开启一个线程去执产品经理待遇及线程是什么意思发展行一个任务html简单网页代码，并且这个任务执行完成后有一个返回值。

JDK效率符号提供了Callabhtml标签属性大全le接口与F线程数越多越好吗uture接html个人网页完整代码口为我们解决这个问题，这也是所谓的“产品经理证书异步”模型。

Callable接口

Callable与Runnable类似，同样是只有一个抽象方法的函数式接口。不同的是，Callable提供的方法是有返回值的，而且支持泛型。

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

那一实例化是什么意思般是怎么使用Ca效率与公平的关系是什么l效率与公平的关系是什么lable的呢？Callable一般是配合线程池工具ExecutorServic产品经理培训e来使用的。我们会在后续章节效率的英文解释线程池的使用。这里只介绍Ehtml5x效率是什么意思ec线程池utorSe实例化对象是什么意思rvice可以使用submit方法产品经理培训来让一个Callable接口执行。它会返回一个Future，我们后续的程线程池序效率可以通过这个Fut效率符号ure的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()); 
    }
}

输出结果：

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方法是试图线程取消一个线程的执行。

注意是试图取消，并不一定能取消成功。因为任务可能已完成、已取消、产品经理是做什么或者一些其它因素不能取消，存在取消线程数越多越好吗失效率计算公式败的可能。boolea效率至上主义的快穿游戏n类型的返回值是“是否取消成功”的意思。参产品经理数paramBoolean表示是否采用中断的方式线程数越多越好吗取消线程执行。

所以有效率的拼音时候，产品经理是做什么为了让任务有能产品经理的职责够取消的功能，就使用Callable来代替Runnable产品经理工资一般多少。如果为了可取消性而使用 F产品经理是做什么uture但又不提供可用的结果，则可以声明 Future<?>形式类型、并返回 null作为底实例化对象层任务的结果。

Fuhtml是什么意思tureTask类

上线程面介绍了Fhtml个人网页完整产品经理的职责代码uture接口。这个接口有一个实现类叫FutureTask。FutureTask是实现的RunnableFuture接口的，html网页制作而RunnableFu产品经理工资一般多少tur实例化对象是什么意思e接口同时继承了Runnabl产品经理培训e接口和Futur产品经理证书e接口：

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());
    }
}

使用上与第一个Dehtml简单网页代码mo有一点小线产品经理待遇及发展程的几种状态的区别。首先，调用submit方实例化法是没有返线程安全回值的。这里实际上是调效率计算公式用的submit(Runnable task)方法，而上面的Dem类的实例化ohthtml标签ml个人网页完整代码，调用的是submit(Callabhtml简单网页代码le task)方法。

然后，这里是使用Fut线产品经理待遇及发展程撕裂者ureTashtml是什么意思k直接取get取值，而上面的Demo是通过submit方法返回的Future去取值。效率是什么意思

在很多高并发的环境下，有可能C实例化对象allable和FutureTask效率与公平的关系是什么会创建多次。FutureTask能够线程的概念在高并发环境下确保任务只执行一次。

反射

一、反射的概述

Java反射机制是实在运线程安全效率的拼音行状态中，对于任意一个类，都能够知道这个类的属性和方法；对于任意一个html网页制作html文件怎么打开线程的几种状态对象，效率符号都能够调用它的html代码任意一个方法和属性；这种动态获取信息以及动态调用对象的方法的功能我们称之为Ja效率符号va反射机html标签制。

想要剖析一个类线程的概念，必须要获取该类的的字节码文件对象。而剖析使用的就是Cl效率高发票查验ass类的方法，产品经理培训所以要先获取效率控一个字节码文件对类的实例化应的Cl实例化对象是什么意思ass类型的对效率高发票查验象。

*以上的总结就是什么是反射*

反射就是把java类中的各种成分映射成一个个的Java对象

例线程池如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个线程是什么意思组成部分映射成一个个对象。

（其实：html5一个类中这些成员方法、构造方法、在加入类中都有一个类来html代码描述）如图是类的正常加载过程：反射的原理效率的拼音在与class对象。熟悉一下加载的线程撕裂者时候：Class对象的由来是将class文件读入内存，并为之创建一个Class对象。

线程的概念

其中这个Cl效率是什么意思ass产品经理是做什么对象很特殊。我们先了解一下这个C la线程是什么意思ss类

二、查看Class类线程池在Java中api详解（查阅文档）

Class 类的实例表示正在运行的 Java 应用程序中的类和接口线程和进程的区别是什么。也就是jvm中有N多的实效率例每效率计算公式个类都有该Cla效率公式ss对象。（包括基本数据类型）

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineC效率是什么意思lass 方法自动线程是什么意思构造的。也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了线程。

没html简单网页代码有公共的构造方法，方法共有6产品经理待遇及发展4个太多了。咱们只需要了解一些常用的即可

三、反射的使用

下面我们来举一个例子：

先写一个Student类。

1、获取Class对象的html网页制作三种方式

Object ——> getClass();产品经理的职责
任何数据类型（包括基本数据线程的几种状态类型）都有一个“静态html是什么意思”的c线程池lass属性
通过Class的静态方法：forName（String className）(常用)

其中1.1是因为Object类中的getClhtml文件怎么打开ass方法、因为所有类都继承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、通过反射获取构造方法并使用：

studen效率至上主义的快穿游戏t类：

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 Construct线程是什么意思or[] getConstructors()：所有”公有的”构造方法 puhtml是什么意思blic Constructor[] getDeclaredConstructors()：获取所有线程池的构造方法(包括私有、受保护、默认、公有线程是什么意思)

2).获取单个的方法，并调用：效率 public C产品经理onstructor get效率的英文Constructo效率高发票查验r(实例化对象是什么意思Class… p实例化对象arameterTypes):获实例化对象是什么意思取单个的”公有的”构造方法： public C实例化对象onstr线程是什么意思uctor gehtml个人网页完整代码tDeclaredConstructor(C产品经理lass… parameterTypes产品经理工资一般多少):获取html网页制作“某个构造方法”线程数可以是私有的，或受保护、默认、公有；

调用构造方法： Constructor–>newInstance(Object… initargs)

2、 newInstance是 Constructor类实例化的方法（管理构造函数的类） ap效率符号i的解释为： 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=

由此可见调用字段时：需要传线程递两个参数：

Obj效率公式ect obj =HTML s产品经理是做什么tuClass.getConstructor().newInstance()效率的拼音;//产生Shtmltudent对象–》S线程tudent stu = new Student();html //为字段设置值 f.set(obj, “刘德华”);//为产品经理培训Student对象中的name属性赋值–》stu.name = “刘德华” 第一个参数：要传入设置html代码的对象，类的实例化第二个参数：要传入实参

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);html标签属性大全//调用制定方法（所有包括私有线程的概念的），需要传入两实例化对象是什么意思个参数，第一实例化对象个是调用的效率与公平的关系是什么方法名称，第二个是方法的形参类型，切记是类型。产品经理和项目经理区别有哪些

System.out.print产品经理待遇及发展ln(m); m.setAccessible(true);//解除私有限产品经理待遇及发展定 Object result = m.i产品经理工作流程nvoke(obj, 20);//需要线程的几种状态两个参数，一个是要调用的对象（获取有反射），一个是实参 System.out.printl线程是什么意思n(“返回线程安全值：类的实例化” + 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()方法。还有字段组成，这些内html文件怎么打开容在内省中效率公式详解

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值
	}
}

执行结html文件怎么打开果：

is show()

需求：产品经理工资一般多少 当我们升级这个系统时，不要Student类，而需要新写一个Student产品经理待遇及发展2的效率是什么意线程数思类时，这时只需要更改pr产品经理待遇及发展o.txt的文件内容就可以了。效率是什么意思代码就一点不用改动

要替换的student2类：

public class Student2 {
	public void show2(){
		System.out.println("is show2()");
	}
}

配html代码置文件更改为：

className = cn.fanshe.Student2
methodName = show2

执产品经理的职责行结果：

is show2();

7、反射产品经html文件怎么打开理待遇及发展方法的其它使用之—通过反射越过泛型检查

泛型用在编译期，编译过后泛型擦除（消失掉）。所以是可以通过反射越过泛型检查的

测试类：

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 中文译过来html简单网页代码线程的概念就是注解、标释的html5意思，线程数在 Jav实例化是什么意思a 中注解是一个很重要的知识点，但经常还是有点让新手不容易理解。

我个人认为，比较糟糕的技术文档主要特征之一就线程数是：用专业名词来介绍专业名词。 比如：线程安全

Java 注解用于为 Java 代码提供元产品经理工资一般多少数据。作为元数据，注解不直接影响你的代码执行，但也有一些类型的注产品经理需要具备的能力解实际上可以用于这一目的效率公式。Java 注解是从 Javahtml文件怎么打开5 开始类的实例化添加到 Java 的。这是大多数网站上对于 Java 注解，实例化对象是什么意思解释确实正确HTML，但实例化是说实在话，我第一次学习的时候，头脑一片空白。这什么跟什么啊？听了像没有听一样。因为概念太过于抽象，所以初学者实在是比较吃线程的概念力才能够理解，然后随着自己开发过程中不断地强化练习，才会慢慢对它形产品经理工作流程成正html标签确的线程和进程的区别是什么认识。

我在写这篇文章的时候，我就在思考。如何让自己或线程和进程的区别是什么者让读者能够比较直观地认识注解这个概效率至上主义的快穿游戏念？是要去官方文档上翻译说明吗？我马上否定了这个答案。

后来，我想到了一html标签样东西————墨水，墨水可以挥发、可以有不同的颜色，用来解释产品经理待遇及发展注解正好。

不过，我继续发散思维后，想到了一样东西能够更好地代替墨水，那就是印章。印章效率是什么意思可以沾产品经理工作流程上不同的墨水或者印泥，可以定制印章的文字或者图案，如果愿意它也可以被戳到你任何想戳的物体表面。

但是，我html是什么意思再继续发散思维后，又想到一样东西能够更好地代替印章，那就是标签。标签是一张便利纸，标签上的内容可以自由定义。常见的如货架上的商品价格标签、效率的英文图书馆中的书本编码标签、实验室中化学材料的名称类别标签等等。

并且，往抽象效率地说，标签并不一定是一张纸，它可以是对人和事物的属性评价。也就是说，标签具备对于抽象事物的解释。

所以，基于如此，我完成了自我的知识认知升级，我决定用标签来解释注解。

注解如同标签

之前某新闻实例化是什么意思客户端线程数越多越好吗的评论有盖楼的习惯，于是 “乔布斯重新定义了手机、罗永浩重新定义了傻X” 就经常极为工整地出现在了评论楼层中，并且效率与公平的关系是什么广大网友在相当长的一段时间内对于这种行为乐此不疲。这其html代码实就是等同于产品经理需要具备的能力贴标签的行为。在某些网友眼中，罗永浩就成了傻X的代名词。

广大html简单网页代码网友给产品经理需要的技能罗永浩贴了一个名为“傻x”的标签，他们并不真正了解罗永浩，不知道他当教师、砸冰箱、办博客的壮举，但是因为“傻x”这样的标签存在线程的概念，这有助于他们直接快速地对罗永浩这个人做出评价，然后基于此，罗永浩就可以成为茶余饭后的谈资，效率控这就是标签的力量。

而在网络的另一边，老罗靠他的人格魅力自然收获一大批忠实的拥泵，他们对于老罗贴的又是另html代码一种标签。

我无意于评价这两种行为，我再引个例子。

《奇葩说》是近年网络上非常火热的辩论节目，其中辩手陈铭被另外一个辩手马薇薇攻击说是————“站在宇宙中心呼唤爱”，然后贴上了一个大大的标签————“鸡汤男”，自此以后，观众再看到陈铭的时候，首先映入脑海中便是“鸡汤男”三个大字效率，其实本身而言陈铭非html常优秀，为人师表、作风正产品经理需要具备的能力派、谈html个人网页完整代码吐举止得体，但是产品经理的职责在网络中，线程是什么意思效率因为娱乐至上的环境所致，人们更愿意以娱乐的心态来认知一线程切效率符号，于是“鸡汤男”就如陈铭自己所说成了一个撕不了的标签。

我html个人网页完整代码们可以抽象概括一下，标签是对事物行为的某些角度的评价与解释。

到这里，终于可以引出本文的主角注解了。

初学html标签者可以这样理效率解注解：想像代码具有生命，注解就是对于代产品经理和项目经理区别有哪些码中某些鲜活个体的贴上去的一张标签。产品经理需要的技能简化来讲，注解如同一张标签。

在未开始学习任何注解具体语法而言，你可以把注解看成一张标签。这产实例化是什么意思品经理需要具备的能力有助于你快速地理解它的大致作用。如果初学产品经理需要的技能者在学习过程有大脑放空的时候，请不要慌张，对自己说：

注解，标签。注解，标签。

注解的html个人网页完整代码语法

因为平常开发少见，相信有不少的人员会认为注html网页制作解的地效率高发票查验位不高。其实效率公式同 classs 和 interface 一样，注解也属于一线程的几种状态种类型。它是在 Java SE 5.0 版本中开始引入的概念。

注解的定义

注解通过 @interfacehtml网页制作关键字进行定义。

public @interface TestAnnotation {
}

它的html简单网页代码形式跟接口很类似html简单网页代码，不效率过前面多了一个 @ 符号。上面实例化html是什么意思是什么意思的代码就创建了一个名字为 TestAnnotaion 的注html简单网页代码解。

你可以简单理解为创建了一张名字为 TestAnnotation 的标签。

注解的应用

上面创建了一个注解，那么注解的的使效率用方法是什么呢。

@TestAnnotation
public class Test {
}

创建一个类 Test,然后在类定义的地方加上 @TestAnnotation 就可以用 TestAnno效率符号tation 注产品经理解这个类了。

你html标签可以简单理解为将 TestAnnotation 这张标签贴到 Test 这个类产品经理需要的技能上线程面。

不过，要想注解能够正常工作，还需要介绍一效率符号下一产品经理需要的技能个新的概念那就是html简单网页代码元注解。

元注解

元注html简单网页代码解是什么意思呢？

元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面。

如果难于理解的话，你可以这样理解。元注解也是一张标签，但是它是一张特殊的标效率的拼音签，它的作用和目的就是给其线程和进程的区别是什么他普通的标签进行解释说明的。

元标签有 @Retention、@Docum线程ented、效率高发票查验@Thtml简单网页代码arget、@Inherited、@Repeatable线程的概念 5 种。

@Reten实例化对象tion

Retention 的英文意为保留期的意思。当 @Retention 应用到一个注解上的时候，它解释说明了这个注解的html的存活时间。

它的取值如下：

Rehtml网页制作tent产品经理工资一般多少ionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时它将被丢弃忽视。

RetentionPolicy.CLASS 注解只被保留到编译进行的时候，html个人网页完整代码它并不会被加载到 JVHTMLM 中。

Ret产品经理是做什么entionPolicy.RUNTIME 注解可以保留效率控到程序产品经理和项目经理区别有哪些运行的时候，它会被加载进入到 JVM 中效率高发票查验，所以在程序运行时可以获取到它们。

我们可以这样的方式线程池的七个参数来加深理解，@Retention 去给一张标签解释的时候，它指定了这张线程池标签张贴的时间。@Retention 相当于给一张标签上面盖了一张时间戳，时间戳指明了标签张贴的时效率间周期。

@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
}

@Documented

顾名思义，这个元注解肯定是和效率是什么意思文档有关。它的作用是能够将注解中的元素包含到 Javadoc 中去。

@Target

Target 是目标html个人网页完整代码的意思，@Target 指定了注解运用的地方。

你可以这样理解，当一个注解被 @Target 注解时，这个注产品经理工资一般多少解就被限定了运用的场景。

类比到标签，线程池原本标签是你想张贴到哪个地方就到哪个地html简单网页代码方，但是因为 @Targe产品经理需要具备的能力t 的存在，它html是什么意思张贴的地方就html网页制作非线程数常具体了，比如只能张贴到方法上、类上、方法参数上等等。@Target 有下面产品经理需要的技能的取值html标签

Elemehtml5ntType.ANNOTATION_TYPE 可以给一个注解进行注解

ElementType.CONSTRUCTOR 可以给构造方法进行注解

ElementType.FI线程安全ELD 可以给属性进行注解

ElementTy产品经理是做什么pe.LOCAL_VARIABLE 可以给局部变量进行注HTML解

ElementType.METHOD 可以产品经理工资一般多少给方法进行注解

ElementType.PACKAGE 可以给一个包进行线程安全注解

Elementhtml简单网页代码Type.PARAMETER 可以给一个方法内的参数进行注解

ElementType.TYPE 可以给一个类型进行注解，比如类、接口、枚举

@I实例化nherited

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 这个注效率符号解。

可以这样理解：

老子非常有钱，所以人们给他贴了一张标签叫做富豪。

老子的儿子长大后线程安全，只要没有和老子断绝父子关系，虽然别人没有给他贴标签，但是他自然也是富豪。

老子的孙子长产品经理需要具备的能力大类的实例化了，自然也是富豪。

这就是人们口中戏称的富一代，富二代，富三代。虽然叫线程是什么意思法不同，好像好多个标签，但其实事情的本质也就是他们有一张共同的标签，效率的英文也就是老子身上的效率控那张富豪的标签。

@实例化对象是什么意思Rep产品经理eatable

Rhtml5epe效率符号atable 自然是可重复的意思。@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{
}

注意上面的代码，@Rehhtml文件怎么打开tmlpeatable 注解了 Person。而 @Repeatable 后面括号中的类相当于一个容器注解。

什么是容器注解呢？

就是用来存放其它注解的地方。它本身也是一个注解。

我们再看看代码中的相关容器注解。

@interface Persons {
    Person[]  value();
}

按照规定，它里面线程的几种状态必须产品经理工资一般多少要有一个 value 的属性，属性类型是一个被 @R线程数ehtml标签peatable 注解过的注解数组，注意它是数组。

如果不好理解的话，可以这样理解。Pers效率o产品经理培训ns 是一张总的标实例化签，上面贴满了 Person 这种同类型但内容实例化不一样的标签。把 Persons 给一个 SuperMan 贴上，相当于同时给他贴了程序员、产品经理、画家的标签实例化。

我们可能对于 @Per产品经理需要html是什么意思具备的能力son(role=”PM”) 括产品经理的职责号里面的内容感兴html网页制作趣，实例化是什么意思它其实就是给 Person 这个注解的 role 属性赋值为 PM ，大家不明白正常，马上就讲到注解的属性这一块。

注解的属性

注解的属性也叫做成员变量。注解只有成员变量，没有方法产品经理工资一般多少。注解的成员变量在注解的定义中以“无形参的方法”形式来声明，其方法名定义了效率的英文该成员变量的名效率的英文字，其返回值定义了该成员变量的类效率效率符号型。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
    int id();
    String msg();
}

上面代码定义了 TestAnnotation 这类的实例化实例化个注解中拥有 id 和 msg 两个属性。在使用的时候，我们应该给它们进行赋值。

赋值的产品经理和项html标签目经理区别有哪些方式是在注解的括号内以 value=”” 形式，多个属性之前用，隔开。

@TestAnnotation(id=3,msg="hello annotation")
public class Test {
}

需要注意的是，在注解中html标签定义属性时它的类型必须是 8 种基本数据类型外加类、接口、注解及它们的数组效率的拼音。

注解中属性可以有默认值，默认值需要用 default 关键值指定。比如：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
    public int id() default -1;
    public String msg() default "Hi";
}

Teshtml个人网页完整代码tAnnotation 中 id类的实例化属性默认值为 -1，msg 属性默认值为 Hi实例化是什么意思。它可以这样应用。

@TestAnnotation()
public class Test {}

因为有默认值产品经理证产品经理需要的技能书，所以无需要再在 @Tehtml是什么意思stAnn产品经理工作流程otation 后面的括号里面进行赋值了，这一步可以省略。

另外，还有一种情况效率是什么意思。如果一个注解内仅仅只有一个名字为 value 的属性时，应用这个注解时可以直接线程的概念接属性值填写到括效率实例化对象至上主义的快穿游戏号内。

public @interface Check {
    String value();
}

上面代码中，Check 这个注解只有 value 这个属性。所以可以这产品经理的职责样应用。

@Check("hi")
int a;

和这下面实例化效率公式对象是什么意思的效果是一样的

@Check(value="hi")
int a;

最后，还需要注意的一种情况是一个注解没有任何属实例化对象性。比如html网页线程制作

public @interface Perform {}

那么在应用这个注解的时候，括号都可以省略。

@Perform
public void testMethod(){}

Java 预置的产品经理证书注解

学习了上面相关的知识线程池的七个参数，我们已经可以自己定义一实例化对象个注解了。其实 Java 语言产品经理证书本身已经提供了效率公式几个现成的注解。

@Deprecated

这个元素是用来标记过时的元素效率控，想必大ht线程的概念ml网页制作家在日常开发中经常碰到。编译器在编译阶段遇到这个注解时会发出提醒警产品经理培训告，告产品经理工HTML作流程诉开发html文件怎么打效率的英文开者正在调用一个过时的元素比如过时的方法、过时的类、过时的成员变量。

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() 被 @Deprecat效率的英文ed 注解。然后我们在 IDE 中分别调用它们。

可以产品经理和项目经理区别有哪些看到，say() 方法上面被一条直线效率符号划了一条，这其实就是编译器识别后的提醒效果。

@Override

这个大家应该很熟悉实例化对象是什么意思了，提产品经理需要的技能示子类要复写父类中被 @Override 修饰的方法

@SuppressWarni实例化对象ngs

阻止警html文件怎效率至上主义的快穿游戏么打开告的意思线程的概念。之前说过调用被 @Deprecated 注解的方法后，编译html标签器会警告提醒，而有时候开发者会效率的英文忽略这种警线程安全告，产品经理的职责他们产品经理工资一般多少可以在调用的地方通过 @SuppressWarnings效率是什么意思达到目的。

@SuppressWarnings("deprecation")
public void test1(){
    Hero hero = new Hero();
    hero.say();
    hero.speak();
}

@SafeVarargs

参数安全类型注解。它的实例化是什么意思目的是提醒开发者不要用参效率是什么意思数做一些不安全的操作,它的存在会阻止编译产品经理工作流程器产效率与公平的关系是什么生 u产品经理需要具备的能力nchecked 这样的警告。它是在 J效率高发票查验ava 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!
}

上面的代码中，编译阶段不会报错，但是运行时会抛出 Cl效率的拼音assCastException 这个异常，所实例化对象以它虽然告诉开发者要妥善处理，但实例化是开发者自己还是搞砸了。

Java 官方文档说，未来的版本会授权编译器对这种不安全的操作产生错误警告。

@FunctionalInterface

函数式接口注解，这个是 Java 1.8 版本引入的新特性。函数式编程很火，所以 Java 8 也及时效率计算公式添加了这个特性。

函数效率公式式接口 (Functional线程安全 Inhtml标签属性大全terface) 就是一个具有一个方法的普通接口。比如

@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 就是一个典型的函数式接口，上面源码可以看到它就被 @Func产品经理培训tionalInterfhtml个人网页完整代码ace 注解。

可能有人会疑惑，函数式接口标记有什么用，这个原因是函数式接口可以很容易转换为 Lambda 表达式。这html标签属性大全是另外的主题了，效率计算公式有兴趣的同学请自己搜索相关知识点学习html标签属性大全。

注解的提取

博文前面的部分讲了注解的基本语法，现在是产品经理待遇及发展时候检测HTML我们所学的内容了。

我通过用标签来比作注解，前面的内容产品经理培训是讲怎么写注解，然后贴到线程撕裂者哪个地方去，而现在我们要html网页制作做的工作就是检阅这些标签内容。形产品经理需要具备的能力象的比喻就是你把这些注解标签在合适的时候撕下来，然后检阅上面的html简单网页代码内容信息。

要想正确检阅注解，离不开一个手段，那就是反射。

注解与反射产品经理是做什么

注产品经理和项目经理区别有哪些解通过反射获取。首先可以通过 Class 对象的类的实例化 isAnnotationPresent(类的实例化) 方法产品经理的职责判线程的概念断它是否应用了产品经理需要的技能某个注解

public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {}

然后通线程和进程的区别是什么过 getAnnotation() 方法实例化来效率符号获产品经理需要具备的能力取 Annotation 对象。

 public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {}

或者是 getAnnotations() 方法。

public Annotation[] getAnnotations() {}

前一种方法返回指定类型的注解，后一种方法返回注解到这个元素上的所有注解。

如html标签属性大全果获取到的 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

需要html个人网页完整代码注意的是，线程产品经理培训的概念如果一个注解html个人网页完整代码要在运行时被成功提取，那么 @Ret线程安全ention(Retention产品经理工资一般多少html网页制作Policy.RUNTIME) 是必须的。

注解的使用场景

我相信博文讲到这里大实例化对象家都很熟悉了注解，但是有不少同学肯定会问，注解到底有什么用呢？

对啊线程池的七个参数注解到底有什么用？

我产品经理工作流程们不妨将目光放到 Java 官方文档上来。

文章开始的时候，我用标签来类比注解。但标签线程比喻只是我的html是什么意思手段，而html标签不是目的。为的是让大家在初次学产品经理证书习注解时能够不被那些抽象线程数的新概产品经理待遇及发展念搞懵。既然现在，我们已经对注解产品经理是做什么有所了解，我们不妨再仔细阅读官方最严谨的实例化文档。

注解是一系列元数据，效率符号它提供数据用来解释程序代码，但是注解并非是所解释的代码本身的一部分。注实例化对象解对于代码的运行效果没有直接影线程响。

注产品经理证书解有许多用处，主要如下：

提供信息给编译器：编译器可以利用线程注解来探测错误和警告信息

编译阶段时的处理：软件工具线程池可以用来利用注解信效率与公平的关系是什么息来生成代码、Html文档或者做线程安全其它相应处理html是什么意思。

运行时的处理线程池的七个参数：某些注解可以在程序运行的时候接受代码的提取值得注意的是，注解不是代码本身的一线程数越多线程撕裂者越好吗部分。

如果难于理解，可以这样看。罗永浩还是罗永浩，不会因为某些人对于他“傻产品经理工作流程x”的评价而改变，标签只是某些人对于其他事物的评价，但是标签不会改变事物本身，标签只是特线程和进程的区别是什么定人群的手段。所以，注解同样无法改h线程数越多越好吗tm类的实例化l标签属性大全变代码本身，html文件效率符号怎么打开注解只是某些工具的的工具。

还是回到官方文档的解释上，注解主要线程线程数越多越好吗的几种状态针对的是编译器和其它工具软件(SoftWare tool)。

当开发者使用了Annotation 修饰了类、方法、Field 等成员之后，这些 Annotation 不会自己生效，必须由开发者提供线程数越多越好吗相应的代码来提取并处理 Annotation 信息。这些处理提取和处理 Annohtml是什么意思tation 的代码统称为 APT（Annotation Processing Tool)。

现在，我们可以给自己答案了，注实例化对象解有什么用？给谁用？给编译器或者实例化对象是什么意思 APT 用的。

如效率至上主义的快穿游戏果，你还是没有产品经理待遇及发展搞html清楚的话，我亲自写一个好了。

亲手自定义注解完成某个目的

我要写一个测试框架，线程撕裂者测html文件怎么打开试程序员线程数越多越好吗的代码有无明效率控显的异常线程是什么意思。

—— 程序员 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!");
    }
}

上面的代html代码码，有些方法上面运用了 @Jiecha 注解。

这个注解是我写的测试软件框架中线程撕裂者定义的HTML注解。

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() 这个方类的实例化法有异常，这个异常名称叫做 Arit产品经理是产品经理需要的技能做什么hmeticException，原因是运算效率计算公式过程中进行了除 0 的操作。html标签属性大全

所以，NoBug 这个类有 Bug。

这样，通过注解我完成了我自己的目的，那就是对别人的代码进行测试。

所以，再问我注解什么时候用？我只能告诉你，这取决于你想利用它干什么用。

注解html网页制作应用实例

注解效率的拼音运用的地方太多了，如： JUnit 这个是一个测试框架，典型使用方法如下：

public class ExampleUnitTest {
    @Test
    public void addition_isCorrect() throws Exception {
        assertEquals(4, 2 + 2);
    }
}

@Test 标记效率了要进html标签属性大全行测试的方法 addition_isHTMLCorrect().

还有例如s实例化对象是什么意思sm框架等运用了大量的注解。

JavaSE阶段就告一段落了，希望这个Java基础笔记能让更多的人深刻理解Java基础，并且快速入效率门！祝大家前程似锦！

全网最详细Java基础笔记—–第三部分

Java多线程

引言

什么是进程，线程？

线程的应用实例：

为什么需要使用多线程？

CPU调度算法

一、Java多线程基础

创建html5线程的方式

1.继承Thre线程ad类创建线程

2.实现Runnable接口创建线程

3.使用匿名内部类形式创建线程

4.使用Lambda表产品经理待遇及发展达式创建

5.使产品经理产品经理的职责实例化对象是什么意思用Callable和 Future创建线效率程

6.使用线程池创建

7.Spring中的@Asynhtml个人网页完整代码c创建

Thread中的常线程的几种状态用的方html代码法

1.Thread.cur产品经理是做什么rentThread() 方法可以获得当前线程

2.setName()/getNa产品经理需效率计算公式要的技能me

3.isAlive()

4.sleep()

5.getId() java中的线程都有一个唯一编号

6.yield() 放产品经理弃当前的cpu资源

7.setPriority() 设置线程的优先级

8.interrupt()中断线程 (产品效率的拼音经理工产品经理培训作流程Thread中的方法。)

9.setDaemon() 守护产品经理和项目经理区别有哪些线程

线程的状态（线程的生命周期）

二、线程安全原理篇

多线程的html个人网页完整代码好处效率至上主义的快穿游戏：

多线程的问题：html标签属性大全

常见html标签的线程活性问题：

什么是线程安全问题？

原子性(Atomic)：

可见性(visbility)：

有序性(Orde效率至上主义的快穿游戏ring)：

JVM线程是什么意思与JMM

JVM运行时数据区

出现线程不安全的例子

三、线程同步

锁的概念

内部锁：synchronized

synchronized的几种使用场景：

多线程访问同步方法的7种情况

死锁的问题

四、线程之间的通信

等待/通知机制

interrupt()方法会中断wait()

notify()与notifyAll()

wait(long)

wait() 等待条件发HTML生了变化

join()

五、Calla类的实例化ble与Future

Future接口

Fuhtml是什么意思tureTask类

反射

一、反射的概述

二、查看Class类线程池在Java中api详解（查阅文档）

三、反射的使用

1、获取Class对象的html网页制作三种方式

2、通过反射获取构造方法并使用：

3、获取成员变量并调用

4、获取成员方法并产品经理需要的技能调用

5、反射main方法

6、反射方法的其它使用之—通过反射线程运行配置文件内容

7、反射产品经html文件怎么打开理待遇及发展方法的其它使用之—通过反射越过泛型检查

注解

注解的概述

注解如同标签

注解的html个人网页完整代码语法

注解的定义

注解的应用

元注解

@Reten实例化对象tion

@Documented

@Target

@I实例化nherited

@实例化对象是什么意思Rep产品经理eatable

注解的属性

Java 预置的产品经理证书注解

@Deprecated

1.继承`Thre线程ad`类创建线程

2.实现`Runnable`接口创建线程

4.使用`Lambda`表产品经理待遇及发展达式创建

5.使产品经理产品经理的职责实例化对象是什么意思用`Callable`和 `Future`创建线效率程

7.Spring中的`@Asynhtml个人网页完整代码c`创建

`Thread`中的常线程的几种状态用的方html代码法

1.`Thread.cur产品经理是做什么rentThread() 方法可以获得当前线程`

2.`setName()/getNa产品经理需效率计算公式要的技能me`

3.`isAlive()`

4.`sleep()`

5.`getId()` java中的线程都有一个唯一编号

6.`yield()` 放产品经理弃当前的cpu资源

7.`setPriority()` 设置线程的优先级

8.`interrupt()`中断线程 (产品效率的拼音经理工产品经理培训作流程Thread中的方法。)

9.`setDaemon()` 守护产品经理和项目经理区别有哪些线程