one-17 线程池 设计模式 注解 反射

1.线程池的创建方式

使用实现Runnable接口的方式才能创建线程池

/*多线程编程实现方案三：线程池的方式*/
public class TestRunnableV3 {
    public static void main(String[] args) {
        //1.创建实现类也就是目标业务类对象
        TicketRunnable2 target = new TicketRunnable2();
        /*Executors是用来辅助创建线程池的工具类
         * 常用的方法是：newFixedThreadPool(int)这个方法可以帮我们创建指定数目线程的线程池*/
        //2.使用Excutors工具创建一个最多包含5个线程的线程池对象：ExecutorService
        ExecutorService pool = Executors.newFixedThreadPool(5);
        //3.使用循环启动线程
        for (int i = 0; i < 5; i++) {
            /*execute()让线程池中的线程来执行业务
            每次调用这个方法，都会将一个线程加到就绪对列中
            这个方法的参数，就是我们要执行的具体业务，也就是目标业务类对象target*/
            pool.execute(target);
        }
    }
}

class TicketRunnable2 implements Runnable{
    int tickets = 100;
    Object o = new Object();
    @Override
    public void run() {
        while(true){
            //synchronized (TicketRunnable2.class) {//正确
            synchronized (o) {
                if(tickets>0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("窗口" + Thread.currentThread().getName() + "在卖票" + tickets--);
                }
                if (tickets <= 0) break;//没票就停止循环售票
            }
        }
    }
}

2.设计模式

2.1 单例设计模式

1. 确保一个类中只有一个实例对象
   单例设计模式实现方案一：饿汉式

/*本类用于实现单例设计模式实现方案1:饿汉式*/
public class Singleton1 {
    public static void main(String[] args) {
        //5.在main()中，不通过对象，直接通过类名，调用静态方法
        MySingle single1 = MySingle.getSingle();
        MySingle single2 = MySingle.getSingle();
        //6.用==检验是否是同一个对象
        System.out.println(single1 == single2);//true
        System.out.println(single1);
        System.out.println(single2);
    }
}
//0.创建自己的单例程序
class MySingle{
    //1.提供构造方法，并将构造方法私有化
    /*1.构造方法私有化的目的:为了防止外界随意创建本类对象*/
    private MySingle(){ }

    //2.创建本类对象，并将对象也私有化
    //4.2由于静态资源只能调用静态资源，所以single对象也需要设置成静态
    private static MySingle single = new MySingle();

    //3.提供公共的访问方式，返回创建好的对象
    //4.1为了不通过对象，直接调用本方法，需要将本方法设置为静态
    public static MySingle getSingle(){
        return single;
    }
}

单例设计模式二：懒汉式

/*本类用于实现单例设计模式优化实现方案2:懒汉式
 * 关于单例设计模式的两种实现方式：
 * 1.饿汉式：不管你用不用这个类的对象，都会直接先创建一个
 * 2.懒汉式：先不给创建这个类的对象，等你需要的时候再创建--延迟加载的思想
 * 延迟加载的思想：是指不会在第一时间就把对象创建好占用内存
 *               而是什么时候用到，什么时候再去创建对象
 * 3.线程安全问题：由于我们存在唯一的对象single2,并且多条语句都操作了这个变量
 *   如果将程序放到多线程的环境下，就容易出现数据安全的问题，所以解决方案：
 *   1) 将3条语句都使用同步代码块包裹，保证同步排队的效果
 *   2) 由于getSingle2()只有这3条语句，所以也可以将本方法设置为静态方法*/
public class Singleton2 {
    public static void main(String[] args) {
        //5.调用方法查看结果
        MySingle2 single1 = MySingle2.getSingle2();
        MySingle2 single2 = MySingle2.getSingle2();
        System.out.println(single1 == single2);
        System.out.println(single1);
        System.out.println(single2);
    }
}
//0.创建自己的单例程序
class MySingle2{
    //6.2创建一个静态的唯一的锁对象
    static Object o = new Object();
    //1.私有化本类的构造方法
    private MySingle2(){ }
    //2.创建的是本类对象的引用类型变量，用来保存对象的地址值，默认值是null
    private static MySingle2 single2 ;
    //3.提供公共的get方法
    synchronized public static MySingle2 getSingle2(){
        //4.判断之前是否创建过对象，之前创建过就直接走return
        //之前如果没有创建过，才走if，创建对象并将对象返回
        //6.有共享数据+多条语句操作数据，所以尽量提前处理，避免多线程数据安全隐患
        //6.1 解决方案1：加同步代码块
        //6.2 解决方案2：将本方法getSingle2()设置为同步方法
        //因为这个方法里所有的语句都需要同步
        synchronized (o) {//静态方法中使用的锁对象也得是静态的
            if (single2 == null) {//single2还是默认值，说明之前没有创建过对象
                single2 = new MySingle2();//没创建过才创建，并赋值给single2
            }
            return single2;
        }
    }
}

3.注解

自定义注解

/**本类用于完成自定义注解*/
public class TestAnnotation {

}
//2.通过@Target注解标记自定义注解的使用位置
/* 1.首先注意：注解定于的语法与java不同
 * 2.定义自定义注解的格式：@interface 注解名*/
/*3.通过元注解@Target规定自定义注解可以使用的位置
* 我们使用"ElementType.静态常量"的方式来指定自定义注解具体可以加在什么位置
* 而且，值可以写多个，格式:@Target({ElementType.XXX,ElementType.XXX})*/
@Target({ElementType.METHOD,ElementType.TYPE})//可以加在方法&类上
//3.通过@Retention注解标记自定义的生命周期
/*4.通过元注解@Retention规定自定义注解的生命周期
* 我们使用"RetentionPolicy.静态常量"的方式来指定自定义注解的生命周期
* 注意：值只能写一个：SOURCE  CLASS RUNTIME 三选一*/
@Retention(RetentionPolicy.RUNTIME)//到运行时都有效
@interface Rice{
    //5.可以给注解进行功能增强--添加注解的属性
    /*5.注意：int age(); 不是方法的定义，而是给自定义注解添加了一个age属性*/
    //int age();//给自定义注解添加一个普通属性age，类型是int
    int age() default 0;//给自定义注解的普通属性赋予默认值0
    /*6.注解中还可以添加特殊属性value
    * 特殊属性的定义方式与普通属性一样，主要是使用方式不同
    * 注意：特殊属性的名字必须叫value，但类型不做限制
    * 特殊属性也可以赋予默认值，格式与普通属性一样，不能简写
    * */
//    String value();
    String value() default "Lemon";//定义特殊属性，并给特殊属性赋予默认值
}
//@Rice
class TestAnno{
    /*测试1：分别给TestAnno类 name属性 eat方法都添加Rice注解
    * 结论：属性上的注解报错，说明自定义注解可以加在什么位置，由@Target决定*/
//    @Rice
    String name;
    /*测试2：当我们给Rice注解添加了一个age属性以后，@Rice注解使用时直接报错
    * 结论：当注解没有定义属性时，可以直接使用
    *      当注解定义了属性以后，必须给属性赋值，格式：@Rice(age = 10)*/
    /*测试3：给age属性赋予默认值以后，可以直接使用@Rice注解，不需要给age属性赋值，
    *       因为age属性已经有默认值0了*/
    /*测试4：给Rice注解添加了特殊属性value以后，必须给属性赋值
    * 只不过特殊属性赋值时可以简写成 @Rice("Apple")*/
    /*测试5：如果特殊属性也赋予了默认值，那么可以直接使用这个注解
    * 如果要给注解的所有属性赋值，每条赋值都不能简写*/
//    @Rice(age = 10)
//    @Rice("Apple")
//    @Rice(value = "Apple")
    @Rice
    public void eat(){
        System.out.println("吃饭不积极，帽子有问题");
    }
}

4.反射

1.获取物料类中成员方法

/*本类用于反射的测试*/
public class TestReflect {
    //1.创建程序的入口函数main()--不用
    /*单元测试方法：是Java中最小的测试单位，使用灵活，推荐指数：5颗星
     * 语法要求：@Test + public + void + 没有参数
     * 注意：使用时需要导包：Add JUnit 4 library to the build path
     * 导包后的效果：import org.junit.Test
     * 执行方式：选中方法名前绿色的小三角，成功运行会有绿色的小对勾
     * */
    //2.通过单元测试方法获取类的字节码对象
    @Test
    public void getClazz() throws ClassNotFoundException {
        //此方法的参数是目标类的全路径名：包名.类名，注意抛出异常
        Class<?> clazz1 = Class.forName("cn.tedu.reflection.Student");
        Class<?> clazz2 = Student.class;
        Class<?> clazz3 = new Student().getClass();
        //打印的是刚刚反射获取到的字节码对象，class cn.tedu.reflection.Student
        System.out.println(clazz1);
        System.out.println(clazz2.getName());//打印的是当前字节码对象的全路径名
        System.out.println(clazz3.getSimpleName());//Student,只获取类名
        //package cn.tedu.reflection,获取的是包对象
        System.out.println(clazz1.getPackage());
        //cn.tedu.reflection，根据获取到的包对象，获取包的名字
        System.out.println(clazz1.getPackage().getName());
    }

    //3.通过单元测试方法获取Student类中的方法
    @Test
    public void getFunction() throws ClassNotFoundException {
        //1.获取字节码对象
        Class<?> clazz = Class.forName("cn.tedu.reflection.Student");
        //2.通过字节码对象获取目标类的成员方法
        Method[] ms = clazz.getMethods();
        //3.查看每个方法信息
        //System.out.println(ms);//[Ljava.lang.reflect.Method;@2b05039f
        System.out.println(Arrays.toString(ms));//已经获取到了方法，但是想遍历
        //4.把拿到的方法对象数组进行遍历
        for(Method m : ms){
            //通过每轮循环遍历到的方法对象，获取方法的各种信息
            System.out.println(m.getName());//获取方法名
            Class<?>[] types = m.getParameterTypes();//获取方法的参数类型
            System.out.println(Arrays.toString(types));
        }
    }
}

2.反射获取物料类成员属性，创建物料类无参/全参构造

/*本类用于反射的测试类*/
public class TestReflection {
    //单元测试方法：public + void + 没有参数 + @Test

    //1.通过单元测试方法，获取目标类Student对应的字节码对象
    @Test
    public void getClazz() throws ClassNotFoundException {
        //练习获取字节码对象的3种方式
        Class<?> clazz1 = Class.forName("cn.tedu.review.Student");
        Class<?> clazz2 = Student.class;
        Class<?> clazz3 = new Student().getClass();

        //打印的是Student类对应的字节码对象
        System.out.println(clazz1);//class cn.tedu.review.Student
        //打印的是通过字节码对象获取到的Student的全路径名：包名+类名
        System.out.println(clazz1.getName());//cn.tedu.review.Student
        //打印的是通过字节码对象获取到的Student的类名
        System.out.println(clazz1.getSimpleName());//Student
        //打印的是通过字节码对象获取到的Student的包对象
        System.out.println(clazz2.getPackage());//package cn.tedu.review
        //打印的是通过包对象获取到的包名
        System.out.println(clazz2.getPackage().getName());//cn.tedu.review
    }

    //2.通过单元测试方法练习引用类型数组的定义与遍历
    @Test
    public void getStu() {
        //1.创建Student类的3个对象
        Student s1 = new Student("张三", 3);
        Student s2 = new Student("李四", 4);
        Student s3 = new Student("王五", 5);
        //2.创建数组将刚刚的3个对象存入数组中
        Student[] s = {s1, s2, s3};
        //3.直接打印数组，查看数组中的元素
        System.out.println(Arrays.toString(s));
        //4.遍历学生数组，拿到每一个学生对象，做进一步的操作
        for (Student stu : s) {
            //System.out.println(stu);
            stu.play();//通过遍历到的对象，执行play()
            System.out.println(stu.age);//通过遍历到的对象，打印age属性
        }
    }

    //3.通过单元测试方法，获取Student类中的成员方法
    @Test
    public void getFunction() {
        //1.获取字节码对象
        Class<?> clazz = Student.class;
        //2.通过字节码对象获取目标类中的成员方法们
        Method[] ms = clazz.getMethods();
        //3.通过高效for循环遍历数组，拿到每一个方法对象
        for (Method m : ms) {
            System.out.println(m);//直接打印遍历到的方法对象
            System.out.println(m.getName());//通过方法对象获取方法名
            Class<?>[] pt = m.getParameterTypes();//通过方法对象获取方法所有参数的数组
            System.out.println(Arrays.toString(pt));//打印方法参数的数组
        }

    }

    //4.通过单元测试方法，获取Student类中的构造方法
    @Test
    public void getCons() {
        //1.获取字节码对象
        Class<?> clazz = new Student().getClass();
        //2.通过字节码对象获取目标类Student的构造方法们
        Constructor<?>[] cs = clazz.getConstructors();
        //3.通过高效for循环遍历数组
        for(Constructor c : cs){
            System.out.println(c.getName());//打印本轮遍历到的构造方法的名字
            Class[] pt = c.getParameterTypes();//通过本轮遍历到的构造函数对象获取构造函数的参数类型
            System.out.println(Arrays.toString(pt));//打印参数类型
        }
    }

    //5.通过单元测试方法，获取Student类中的成员变量
    @Test
    public void getFie() throws ClassNotFoundException {
        //1.获取字节码对象
        Class<?> clazz = Class.forName("cn.tedu.review.Student");
        //2.通过字节码对象获取成员变量们
        Field[] fs = clazz.getFields();
        //3.遍历数组，获取每个成员变量的具体信息
        /*注意！目前成员变量的修饰符必须是public的才能获取到，不然，像默认修饰符也是获取不到的*/
        for(Field f : fs){
            System.out.println(f.getName());//通过本轮循环到的字段对象获取字段名
            System.out.println(f.getType());//通过本轮循环到的字段对象获取字段的类型
        }

    }

    //6.通过单元测试方法，创建Student目标类的对象
    @Test
    public void getObject() throws Exception {
        //1.获取字节码对象
        Class<?> clazz = Student.class;
        //2.通过反射技术创建目标类的对象,注意抛出异常
        /*反射创建对象方案1：通过触发目标类的无参构造创建对象*/
        Object o = clazz.newInstance();
        System.out.println(o);//这一步已经获取到了对象Student{name='null', age=0}

        /*反射创建对象方案2：通过触发目标类的全参构造创建对象
         * 思路：
         * 1.先获取指定的构造函数对象,注意需要指定构造函数的参数，传入的是.class字节码对象
         * 2.通过刚刚获取到的构造函数对象创建Student目标类的对象，并且给对象的属性赋值
         * */
        //3.获取目标类中指定的全参构造
        Constructor<?> c = clazz.getConstructor(String.class, int.class);
        //System.out.println(c);
        //4.通过获取到的构造函数：创建对象+给对象的属性赋值
        Object o2 = c.newInstance("赵六", 6);
        System.out.println(o2);
    }
}

3.获取并操作物料类私有资源

/*本类用于练习暴力反射*/
public class TestReflection2 {
    /*1.通过暴力反射获取与操作属性*/
    @Test
    public void getFie2() throws Exception {
        //1.获取字节码对象
        Class<?> clazz = Person.class;
        //2.获取指定的私有属性，传入的是属性名，注意抛出异常
        Field field = clazz.getDeclaredField("name");
        //3.根据刚刚获取到的属性对象，查看属性的信息
        System.out.println(field);//直接打印获取到的字段对象
        System.out.println(field.getType().getName());//java.lang.String
        System.out.println(field.getType());//class java.lang.String

        //4.设置属性的值
        //4.1 需要指定到底是给哪个对象的name属性设置值，没有对象就创建对象
        Object obj = clazz.newInstance();//触发无参构造利用反射创建对象

        //4.2暴力反射，需要设置私有可见权限！！！
        field.setAccessible(true);

        //4.3通过字段对象给刚刚创建好的对象obj设置属性值为海绵宝宝
        //field就是我们刚刚获取的name属性
        //set(m,n)--m是给哪个对象的name属性设置值，n是设置的值是什么
        field.set(obj,"海绵宝宝");
        //4.4 打印查看刚刚设置的属性值
        //field.get(m)--field代表的就是Person类的name属性，m是查看哪个对象的这个属性值
        System.out.println(field.get(obj));
    }

    //2.定义单元测试方法，利用暴力反射操作Person类中的私有属性age
    @Test
    public void getFie3() throws Exception {
        //1.获取字节码对象
        Class<?> clazz = Person.class;
        //2.获取指定的私有属性对象
        Field f = clazz.getDeclaredField("age");
        //3.根据获取到的属性对象，查看相关信息，比如属性的类型
        System.out.println(f.getType().getName());
        //4.操作：设置属性的值：一共需要三个元素：给哪个对象【1】的哪个属性【2】设置一个什么值【3】
        //4.1 需要先指定给哪个对象的这个age属性设置值
        Object obj = clazz.newInstance();
        //4.2 在给属性设置值之前，需要设置权限私有可见，否则报错！
        f.setAccessible(true);
        //4.3通过刚刚获取到的age属性对象，给obj对象设置值
        f.set(obj,17);
        //4.4打印查看刚刚的属性值是否设置成功
        System.out.println(f.get(obj));
    }
    //3.创建单元测试方法，通过暴力反射获取与执行Person类的私有方法
    @Test
    public void getFunction2() throws Exception {
        //1.获取字节码对象
        Class<?> clazz = Person.class;
        //2.可以通过字节码对象获取某一个指定的私有方法对象
        //如何确定要找哪个方法？方法名+参数列表
        Method method = clazz.getDeclaredMethod("save", int.class, String.class);

        /*在执行私有的方法之前，需要设置私有可见的权限！*/
        method.setAccessible(true);

        //3.在执行获取到的方法之前，需要先指定给哪个对象做这个save()操作
        //3.1没有对象就创建对象
        Object obj = clazz.newInstance();
        //3.2通过刚刚获取到的方法对象method给指定的对象obj做操作，注意传参
        //底层会调用obj对象的save方法，传入参数666与"哈哈哈"
        method.invoke(obj,666,"哈哈哈");
    }
}