javase-day11

luoyiang

于 2024-08-21 11:14:17 发布

阅读量300

点赞数 14

文章标签： java 数据库中间件

本文链接：https://blog.csdn.net/m0_64370841/article/details/141333659

版权

aThreadPool_01ThreadPoolDemo

package com.se.aThreadPool;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * execute：执行
 *
 * 线程池的概述：
 *   1. 为什么要引入线程池： 因为多线程会频繁创建和销毁对象，会消耗大量CPU的性能。
 *   2. 什么是线程池： 就是一个线程容器，用来存储固定几个线程对象，当有任务的时候，只需要
 *      将线程池中找到闲置的线程，来处理我们的任务。当任务处理完毕后，将线程归还线程池，并不销毁。
 *      避免了多线程对象的频繁创建和销毁。
 *
 *      这几个固定线程是核心线程，当核心线程都在做任务时，线程池可以维护几个临时线程，可以处理用户的任务。
 *      处理完后，临时线程也不会立即销毁，而是限制一段指定的时间，限制超时就可以销毁了。
 */

public class _01ThreadPoolDemo {
    public static void main(String[] args) {
        /**
          //使用标准方式创建一个线程池对象
          int corePoolSize, //核心线程数
          int maximumPoolSize, //最大线程数(核心线程+临时线程)
          long keepAliveTime, //线程空闲时间，超过时间后，临时线程销毁
          TimeUnit unit, //时间单位
          BlockingQueue<Runnable> workQueue, //任务队列，是一个接口
               常用子类型：
                   ArrayBlockingQueue
                   LinkedBlockingQueue
                   SynchronousQueue

          RejectedExecutionHandler handler //拒绝策略
                AbortPolicy 默认策略  丢弃新的任务，抛出RejectedExecutionException异常
                DiscardPolicy 丢弃新任务，不抛出异常
                DiscardOldestPolicy 丢弃队列中最老的任务，然后把新任务放入队列
                CallerRunsPolicy 运行任务，直接在调用方法的线程中运行

            如果查看一个类的继承关系，选中类名，然后ctrl+H

            前提条件，阻塞队列设置容量
              1. 任务数量<=核心线程数+阻塞队列容量  这种情况，只有核心线程处理任务
              2. 任务数量>核心线程数+阻塞队列容量 并且任务数量<=线程池最大数量+阻塞队列容量
                    这种情况，启用临时线程，核心线程和临时线程处理任务
              3. 如果任务数量>线程池最大数量+阻塞队列容量，就会触发拒绝策略
         */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(5, 10, 60,
                TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(5), new ThreadPoolExecutor.AbortPolicy());
        //添加任务
        for (int i = 0; i < 10; i++) {
            Runnable r = new Task("小" + i);
            pool.execute(r);
        }
        //如果不想要使用线程池，可以使用 pool.shutdown();  该方法是线程池中所有任务执行完后销毁线程池
        pool.shutdown();
        //立即销毁
        //pool.shutdownNow();
    }
}

class Task implements Runnable {
    String name;

    public Task(String name) {
        this.name = name;
    }

    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(name + ":" + i);
        }
    }
}

aThreadPool_02ThreadExcutorsDemo

package com.se.aThreadPool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;


/**
 *  java中大部分场景下，线程池的获取，只需要使用线程池工具类即可
 */

public class _02ThreadExcutorsDemo {

    public static void main(String[] args) {
        /*
          线程池工具类里的常用方法：
            1. static ExecutorService newSingleThreadExecutor()
                : 返回只有一个核心线程的线程池，阻塞队列的容量没指定，理解为int最大值，无临时线程
            2. static ExecutorService newFixedThreadPool(int nThreads)
                : 返回可以指定线程数量的线程池，阻塞队列的容量没指定，理解为int最大值，无临时线程
            3. static ExecutorService newCachedThreadPool()
                : 返回只有临时线程的线程池，临时线程的数量可以是int的最大值，闲置时间60s
            4. static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
                : 返回指定核心线程数量的线程池，临时线程的数量是(int最大值-核心数)，临时线程的闲置时间是0
         */

//        只有一个核心线程，任务串行，执行50s
//        ExecutorService service = Executors.newSingleThreadExecutor();

//        针对于Executors.newFixedThreadPool(5);来说，由5个核心线程来接收任务，并发执行，10个任务，分两批执行。
//        ExecutorService service = Executors.newFixedThreadPool(5);

//        针对于Executors.newCachedThreadPool()来说，由10个临时线程来接收任务，并发执行
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            service.submit(() -> {
                for (int j = 0; j < 10; j++) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName() + ":HelloWorld");
                }
            });
        }

        Runnable runnable = () -> {
            for (int j = 0; j < 10; j++) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName() + ":HelloWorld");
            }
        };
        /*
         * 调度线程池的方法功能很多，可以设置延长时间：
         * 注意：ScheduledExecutorService是ExecutorService的子类型
         *
         * schedule(
         *      Runnable command, //任务
         *      long delay,      //延迟时间
         *      TimeUnit unit    //延迟时间的单位
         *      );
         */
        ScheduledExecutorService scheduler= Executors.newScheduledThreadPool(5);
        for (int i = 0; i < 5; i++){
            //5个核心线程延迟了5秒后并发执行
            scheduler.schedule(runnable, 5, TimeUnit.SECONDS);
        }
    }
}

bDiyClass_MyClass

package com.se.bDiyClass;

import java.util.Arrays;

/**
 * 定义一个类型MyClass，来描述所有的类的特征。
 */
public class MyClass {
    private String className;
    private MyProperty[] properties;
    private MyConstructor[] constructors;
    private MyMethod[] methods;

    public MyClass(String className, MyProperty[] properties, MyConstructor[] constructors, MyMethod[] methods) {
        this.className = className;
        this.properties = properties;
        this.constructors = constructors;
        this.methods = methods;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public MyProperty[] getProperties() {
        return properties;
    }

    public void setProperties(MyProperty[] properties) {
        this.properties = properties;
    }

    public MyConstructor[] getConstructors() {
        return constructors;
    }

    public void setConstructors(MyConstructor[] constructors) {
        this.constructors = constructors;
    }

    public MyMethod[] getMethods() {
        return methods;
    }

    public void setMethods(MyMethod[] methods) {
        this.methods = methods;
    }
    public String toString(){
        return "类名:"+className+"\r\n" +
                "属性列表:"+ Arrays.toString(properties)+"\r\n" +
                "构造器列表："+ Arrays.toString(constructors)+"\r\n" +
                "方法列表："+ Arrays.toString(methods);
    }
    public void addProperty(String type, String name, String value){

    }
}

bDiyClass_MyConstructor

package com.se.bDiyClass;

import java.util.Arrays;

public class MyConstructor {
    private String modifier;
    private String name;
    private MyParameter[] parameters;

    public MyConstructor(String modifier, String name, MyParameter[] parameters) {
        this.modifier = modifier;
        this.name = name;
        this.parameters = parameters;
    }

    public String getModifier() {
        return modifier;
    }

    public void setModifier(String modifier) {
        this.modifier = modifier;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public MyParameter[] getParameters() {
        return parameters;
    }

    public void setParameters(MyParameter[] parameters) {
        this.parameters = parameters;
    }

    public String toString() {
        return modifier + " " + name + " " + Arrays.toString(parameters);
    }
}

bDiyClass_MyMethod

package com.se.bDiyClass;

import java.util.Arrays;

public class MyMethod {
    private String modifier;
    private String returnType;
    private String name;
    private MyParameter[] parameters;
    public MyMethod(String modifier, String returnType, String name, MyParameter[] parameters) {
        this.modifier = modifier;
        this.returnType = returnType;
        this.name = name;
        this.parameters = parameters;
    }

    public String getModifier() {
        return modifier;
    }

    public void setModifier(String modifier) {
        this.modifier = modifier;
    }

    public String getReturnType() {
        return returnType;
    }

    public void setReturnType(String returnType) {
        this.returnType = returnType;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public MyParameter[] getParameters() {
        return parameters;
    }

    public void setParameters(MyParameter[] parameters) {
        this.parameters = parameters;
    }
    public String toString(){
        return modifier + " " + returnType + " " + name + " " + Arrays.toString(parameters);
    }
}

bDiyClass_MyParameter

package com.se.bDiyClass;

public class MyParameter {
    private String type;
    private String name;
    private String value;
    public MyParameter(String type, String name) {
        this.type = type;
        this.name = name;
    }
    public MyParameter(String type, String name, String value) {
        this.type = type;
        this.name = name;
        this.value = value;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
    public String toString(){
        return type + " " + name + " " + value;
    }
}

bDiyClass_MyProperty

package com.se.bDiyClass;

/**
 * MyProperty:这个类用来描述一个属性。
 */
public class MyProperty {
    private String modifier;
    private String type;
    private String name;
    public MyProperty(String modifier, String type, String name) {
        this.modifier = modifier;
        this.type = type;
        this.name = name;
    }

    public String getModifier() {
        return modifier;
    }

    public void setModifier(String modifier) {
        this.modifier = modifier;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public String toString(){
        return modifier+" "+type+" "+name;
    }
}

bDiyClass_Person

package com.se.bDiyClass;

/**
 * 使用Person来描述现实生活中人的特点和行为
 */
public class Person {
    private String idcard;
    private String name;
    private int age;
    private char gender;
    private boolean isMarry;
    private Person() {}
    public Person(String idcard, String name){
        this.idcard = idcard;
        this.name = name;
    }
    private Person(String idcard, String name,int age){
        this.idcard = idcard;
        this.name = name;
        this.age = age;
    }
    public Person(String idcard, String name, int age, char gender, boolean isMarry) {
        this.idcard = idcard;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.isMarry = isMarry;
    }
    public void play(String game) {
        System.out.println(name+"喜欢玩"+game);
    }
    public void sport(String game) {}

    @Override
    public String toString() {
        return "Person{" +
                "idcard='" + idcard + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                ", isMarry=" + isMarry +
                '}';
    }
}

bDiyClass_Pet

package com.se.bDiyClass;

/**
 * 使用Pet来描述现实生活中宠物的特点和行为
 */
public class Pet {
    private String type;
    private String name;
    private int age;
    public Pet(String type, String name, int age) {
        this.type = type;
        this.name = name;
        this.age = age;
    }
    public void eat(String food) {}
    public void sound() {}
}

bDiyClass_TestClassDemo

package com.se.bDiyClass;

public class TestClassDemo {
    public static void main(String[] args) {
        //1. 描述Pet类型的属性
        MyProperty p1 = new MyProperty("private","String","type");
        MyProperty p2 = new MyProperty("private","String","name");
        MyProperty p3 = new MyProperty("private","int","age");
        MyProperty[] ps = new MyProperty[]{p1,p2,p3};
        //2. 描述Pet类型的构造器
        //2.1 先描述参数
        MyParameter param1 = new MyParameter("String","type");
        MyParameter param2 = new MyParameter("String","name");
        MyParameter param3 = new MyParameter("int","age");
        MyParameter[] params = new MyParameter[]{param1,param2,param3};
        //2.2 再描述构造器
        MyConstructor c1 = new MyConstructor("public","Pet",params);
        MyConstructor[] cs = new MyConstructor[]{c1};
        //3. 描述Pet类型的方法
        //3.1 先描述参数
        MyParameter[] mps = new MyParameter[]{new MyParameter("String","food")};
        //3.2 再描述方法
        MyMethod m1 = new MyMethod("public","void","eat",mps);
        //3.3 描述sound方法
        MyMethod m2 = new MyMethod("public","void","sound",new MyParameter[0]);
        MyMethod[] ms = new MyMethod[]{m1,m2};

        //4.描述Pet类型
        MyClass pet = new MyClass("com.se.day11.aClass.Pet",ps,cs,ms);

        System.out.println(pet);

        //获取Pet类型里的所有方法
        MyMethod[] methods = pet.getMethods();
        for (MyMethod method : methods) {
            System.out.println(method.getModifier()+" "+method.getReturnType()+" "+method.getName());
            MyParameter[] parameters = method.getParameters();
            for (MyParameter parameter : parameters) {
                System.out.println(parameter.getType()+" "+parameter.getName());
            }
            System.out.println("-------------------");
        }

    }
}

cClassGet_01GetClassDemo

package com.se.cClassGet;


import com.se.bDiyClass.Pet;

import java.lang.reflect.Field;

/**
 * Class类型介绍
 *  1. 这个类型是用来描述java中的各种类型的，比如可以描述某一个类的类名，所有的属性，
 *     所有的构造器，所有的方法，以及他们的修饰词，返回值类，参数类型等
 *  2. Class这个类的每个具体实例都是用来描述某一个类型的，而且是单例的。
 *     比如，描述String类型的Class的实力在整个系统中有且只有一个
 *  3. 获取某一个类的描述类对象的方式，有三种，
 *        - 对象.getClass()
 *        - 类名.class
 *        - Class.forName(String fullName)
 *      前两种方式并不能完全的体现动态效果，因为提前知道了类的结构
 *
 *    反射：强调的就是一个动态。即获取对象之前完全不知道类的结构，而且是运行期间。
 *
 */

public class _01GetClassDemo {
    public static void main(String[] args) {
        //获取com.se.bDiyClass.Pit
        //方法一:
        Pet p = new Pet("dog","小花",2);
        Class<?> aClass = p.getClass();

        //方法二:
        Class<Pet> bClass = Pet.class;
        System.out.println(aClass == bClass);  //true 表示类的描述对象是唯一的，单例的

        //方法三:
        try {
            Class<?> cClass = Class.forName("com.se.bDiyClass.Pet");
            //获取该对象里面所有的属性(字段 Field),调用的方法中带有Declared的
            Field[] fields = cClass.getDeclaredFields();
            for (Field field : fields) {
                System.out.println(field.getName());
            }

        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }

    }
}

dObjectInstance_01NewInstanceDemo

package com.se.dObjectInstance;

import com.se.ReflectionUtil;
import com.se.bDiyClass.Person;

/**
 * 调用newInstance方法来动态实例化一个类的具体对象
 *
 * 可能出现的异常：
 *    InstantiationException：类实例化异常
 *    NoSuchMethodException：类没有此方法异常
 *    IllegalAccessException：非法访问异常：权限不足
 */

public class _01NewInstanceDemo {
    public static void main(String[] args) {
        try{
            //第一步：通过字符串获取指定类的描述类对象
            //注意：c这个变量里的地址是描述Person类型的信息
            Class<?> c = Class.forName(ReflectionUtil.getClassNameString());
            //调用Class类里的非静态方法newInstance方法来实例化对象
            //注意：本质是调用Person类的无参构造器，如果没有提供无参构造器，就会报错
            Object o = c.newInstance();
            Person p = (Person)o;
            p.play("LOL");

        }catch(Exception e){
            e.printStackTrace();
        };
    }
}

dObjectInstance_02OtherConstructorDemo

package com.se.dObjectInstance;

import com.se.ReflectionUtil;
import com.se.bDiyClass.Person;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * 使用发射机制，调用制定的构造器获取某一个类的对象
 */

public class _02OtherConstructorDemo {
    public static void main(String[] args) {
        try {
            Class c = Class.forName(ReflectionUtil.getClassNameString());
            //如何指定想要的构造器：方法中传入参数类型的描述类对象
            Constructor constructor = c.getConstructor(String.class, String.class);
            //使用构造器的newInstance(Object...parameter)方法给构造器的参数赋值即可
            Object obj = constructor.newInstance("123456", "张三");
            if (obj instanceof Person) {
                Person p = (Person) obj;
                p.play("csgo");
            }
        } catch (ClassNotFoundException | NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

dObjectInstance_03OtherConstructorDemo

package com.se.dObjectInstance;

import com.se.ReflectionUtil;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;


/**
 * 使用权限不足的构造器来获取对象
 */

public class _03OtherConstructorDemo {
    public static void main(String[] args) {
        try {
            Class c = Class.forName(ReflectionUtil.getClassNameString());
            //如何指定想要的构造器：方法中传入参数类型的描述类对象
            Constructor constructor = c.getDeclaredConstructor(String.class, String.class, int.class);

            //如果访问私有的，需要关闭权限校验，true表示关闭校验，默认是false开启校验
            constructor.setAccessible(true);

            //使用构造器的newInstance(Object...parameter)方法给构造器的参数赋值即可
            Object obj = constructor.newInstance("123456", "小梅", 18);
            System.out.println(obj);
        } catch (ClassNotFoundException | NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

ReflectionUtil

package com.se;

import java.io.FileReader;
import java.util.Properties;

/**
 * 反射工具类
 */
public class ReflectionUtil {
    public  static String getClassNameString() {
        String classname = null;
        try(FileReader fr = new FileReader("./reflection.properties")){
           //创建一个Propeties配置文件对象
            Properties prop = new Properties();
            //调用方法读取流里的信息，就会自动将配置文件里的key=value对封装到自身
            prop.load(fr);
            //解析prop，通过key获取value
            classname = prop.getProperty("classname");

        }catch (Exception e){
            e.printStackTrace();
        }
        return classname;
    }

    public static void main(String[] args) {
        System.out.println(ReflectionUtil.getClassNameString());
    }
}