并发包消息队列BlockingQueue与反射api

1、并发包消息队列BlockingQueue
java.util.concurrent.BlockingQueue是并发包下控制线程同步的工具。既然是队列那么其主要的方法当然为入队（push）、出队（pop），这里入队方法有：add、offer、put（阻塞式），出队方法有：pull、take（阻塞式）

1. add（Obj）：该入队方法会在队列满的时候抛出异常。
2. offer（Obj）：如过队列没满能成功入队的话，返回true，如果队列满的话，那么返回false。
3. put（Obj）：入队的时候如果队列满的话，那么会进入阻塞状态，直到有消息出队该对象再入队。
4. pull（time）：出队方法，如果队列内容为空，再等待time时间，取不到那么返回null值。
5. take（）：出队方法，如果队列内容为空，那么进入阻塞状态持续等待，直到有消息入队。

由于BlockingQueue是个接口，通常会使用它的两个实现类，一个是ArrayBlockingQueue一个是LinkedBlockingQueue。
1、ArrayBlockingQueue：一个由数组支持的有界阻塞队列，规定大小的BlockingQueue,其构造函数必须带一个int参数来指明其大小.其所含的对象是以FIFO(先入先出)顺序排序的。

2、LinkedBlockingQueue：大小不定的BlockingQueue,若其构造函数带一个规定大小的参数,生成的BlockingQueue有大小限制,若不带大小参数,所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定.其所含的对象是以FIFO(先入先出)顺序排序的

生产者与消费者实例：

public class Producer implements Runnable{    public BlockingQueue<String> queue;    public Producer(BlockingQueue<String> queue) {        super();        this.queue = queue;    }    @Override    public void run() {        try {            Thread.sleep(300);            String name = Thread.currentThread().getName();            System.out.println(name+"正在入队");            queue.put(name);        } catch (InterruptedException e) {            e.printStackTrace();        }    }}

public class Consumer implements Runnable{    public BlockingQueue<String> queue;    public Consumer(BlockingQueue<String> queue) {        super();        this.queue = queue;    }    @Override    public void run() {        try {            Thread.sleep(200);            String name = Thread.currentThread().getName();            System.out.println(name);            String message = queue.take();            System.out.println(message+"出队完成");        } catch (InterruptedException e) {            e.printStackTrace();        }    }}

public class QueueTest {    static BlockingQueue<String> queue = new ArrayBlockingQueue<>(2);    public static void main(String[] args) {        Producer producer = new Producer(queue);        Consumer consumer = new Consumer(queue);        for (int i=0;i<3;i++){            new Thread(producer,"消息线程"+i).start();        }        for (int i=0;i<5;i++){            new Thread(consumer,"consumer"+i).start();        }    }}

其中一次的输出结果

consumer2consumer3consumer4consumer0consumer1消息线程1正在入队消息线程2正在入队消息线程0正在入队消息线程1出队完成消息线程0出队完成消息线程2出队完成

注：入队的时候休眠是为了让所有消息入队（队列一次最多只能存入两个消息，消息线程0此时是进入阻塞状态等候入队的）后，再进行出队，一旦有个消息出队后那么消息线程0就可以入队了，当三个入队线程1，2，0都出队后，由于还继续在执行出队方法，那么线程就进入了阻塞状态，程序一直不会结束。

2、反射api
实体类Dog

public class Dog implements Animal,Serializable{    public String name;    private int age;    public Dog() {        super();        name = "Wangcai";        age = 18;    }    private Dog(Integer age) {        super();        this.age = age;    }    public Dog(String name) {        super();        this.name = name;    }    public Dog(String name, Integer age) {        super();        this.name = name;        this.age = age;    }    @Override    public void shout() {        System.out.println(name+":旺旺");    }    @Override    public String toString() {        return "Dog [name=" + name + ", age=" + age + "]";    }    private int getPrice(Integer n){        return 999*n;    }}

在同一包下的配置文件db.properties

jdbc.username=rootjdbc.password=123456

测试反射的一些api

public class MyReflect {    public Class dogClass;    public String dogName = "com.scu.reflect.Dog";    /**     * 获得与类名对应的Class类型对象     * @throws Exception     */    @Before    public void init() throws Exception{        dogClass = Class.forName(dogName);    }    @Test    public void test1(){        System.out.println(dogClass);    }    /**     * 获得Class类型对象的直接方式,结果同test1     */    @Test    public void test2(){        System.out.println(Dog.class);    }    /**     * 获得Class类型对象的实例，要求必须有构造方法     * @throws Exception      */    @Test    public void test3() throws Exception{        Dog dog = (Dog)dogClass.newInstance();        System.out.println(dog);    }    /**     * 获取非私有的构造函数     * @throws Exception     */    @Test    public void test4() throws Exception{        Constructor constructor = dogClass.getConstructor(String.class,Integer.class);        //使用构造器创建实例        Dog dog = (Dog)constructor.newInstance("wangcai",18);        System.out.println(dog);    }    /**     * 获取私有的构造函数     * @throws Exception     */    @Test    public void test5() throws Exception{        Constructor constructor = dogClass.getDeclaredConstructor(Integer.class);        //由于是私有的，需要停止权限检查        constructor.setAccessible(true);        //使用构造器创建实例        Dog dog = (Dog)constructor.newInstance(18);        System.out.println(dog);    }    /**     * 获取非私有成员变量     * @throws Exception     */    @Test    public void test6() throws Exception{        Constructor constructor = dogClass.getConstructor(String.class,Integer.class);        //使用构造器创建实例        Dog dog = (Dog)constructor.newInstance("wangcai",18);        Field field = dogClass.getField("name");        //设置值        field.set(dog,"xiaohu");        //获取name属性值        System.out.println(field.get(dog));    }    /**     * 获取私有成员变量     */    @Test    public void test7() throws Exception{        Constructor constructor = dogClass.getConstructor(String.class,Integer.class);        //使用构造器创建实例        Dog dog = (Dog)constructor.newInstance("wangcai",18);        Field field = dogClass.getDeclaredField("age");        //同样需要停止权限检查        field.setAccessible(true);        //设置变量值        field.set(dog, 9);        //获取变量值        System.out.println("年龄:"+field.get(dog));    }    /**     * 获取所有非私有的函数     */    @Test    public void test8() throws Exception{        //获取非私有的成员函数        Method[] methods = dogClass.getMethods();        for (Method method : methods) {            System.out.println(method);        }    }    /**     * 获取指定的非私有的函数     */    @Test    public void test9() throws Exception{        Object object = dogClass.newInstance();        Method method = dogClass.getMethod("shout");        //调用invoke对象的shout方法        method.invoke(object);    }    /**     * 获取私有函数     */    @Test    public void test10() throws Exception{        Object object = dogClass.newInstance();        @SuppressWarnings("unchecked")        Method method = dogClass.getDeclaredMethod("getPrice",Integer.class);        //停止权限检查        method.setAccessible(true);        //返回999*3        Object ob = method.invoke(object,3);        System.out.println(ob);    }    @Test    public void test11() throws Exception{        //获得当前加载class文件的类加载器        System.out.println("类加载器："+dogClass.getClassLoader());        //获得某个实现类的接口        Class[] interfaces = dogClass.getInterfaces();        System.out.println("父接口:");        for (Class clazz : interfaces) {            System.out.println(clazz);        }        //获得父类        Class superclass = (Class)dogClass.getGenericSuperclass();        System.out.println("Dog父类:"+superclass);        /**         * getResourceAsStream这个方法可以获取到一个输入流，这个输入流会关联到name所表示的那个文件上。         */        //path 不以’/'开头时默认是从此类所在的包下取资源，以’/'开头则是从ClassPath根下获取。        //其只是通过path构造一个绝对路径，最终还是由ClassLoader获取资源。        InputStream inputStream = dogClass.getResourceAsStream("db.properties");        System.out.println(inputStream);        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));        System.out.println("读取连接信息");        String line = null;        while(true){            line = reader.readLine();            if(line!=null){                System.out.println(line);            }else {                break;            }        }        reader.close();        //判断当前Class类型对象是否为枚举类型，接口类型等        System.out.println("是否为枚举类:"+dogClass.isEnum());        System.out.println("是否为接口:"+dogClass.isInterface());    }}