五、多线程间通信。
        等待/唤醒机制。
        也就是常见的生产者消费者问题。

        1.当多个生产者消费者出现时，
        需要让获取执行权的线程判断标记。
        通过while完成。
        2.需要将对方的线程唤醒。
        仅仅用notify，是不可以的。因为有可能出现只唤醒本方。
        有可能会导致，所有线程都等待。
        所以可以通过notifyAll的形式来完成 。
这个程序有一个bug。就是每次notifyAll。都会唤醒本方。
可不可以只唤醒对方呢？
JDK1.5版本提供了一些新的对象，优化了等待唤醒机制。
1，将synchronized 替换成了Lock接口。
        将隐式锁，升级成了显示锁。
        Lock
                获取锁：lock();
                释放锁：unlock();注意：释放的动作一定要执行，所以通常定义在finally中。
                获取Condition对象：newCondition();
2，将Object中的wait，notify，notifyAll方法都替换成了Condition的await，signal，signalAll。
和以前不同是：一个同步代码块具备一个锁，该所以具备自己的独立wait和notify方法。
现在是将wait，notify等方法，封装进一个特有的对象Condition，而一个Lock锁上可以有多个Condition对象。

        Lock lock = new ReentrantLock();
        Condition conA = lock.newCondition();
        Condition conB = lock.newCondition();
        con.await();//生产，，消费
        con.signal();生产
        set()
        {
                if(flag)
                        conA.await();//生产者，
                code......;

                flag = true;
                conB.signal();
        }
        out()
        {
                if(!flag)
                        conB.await();//消费者

                code....;
                flag = false;
                conA.signal();
        }
wait和sleep的区别：
wait:释放cpu执行权，释放同步中锁。
sleep:释放cpu执行权，不释放同步中锁。
synchronized(锁)
{
        wait();
}

停止线程：
        stop过时。
        原理：run方法结束。run方法中通常定义循环，指定控制住循环线程即可结束。

        1，定义结束标记。
        2，当线程处于了冻结状态，没有执行标记，程序一样无法结束。
                这时可以循环，正常退出冻结状态，或者强制结束冻结状态。
                强制结束冻结状态：interrupt();目的是线程强制从冻结状态恢复到运行状态。
                但是会发生InterruptedException异常。
线程中一些常见方法：
        setDaemon(boolean):将线程标记为后台线程，后台线程和前台线程一样，开启，一样抢执行权运行，
        只有在结束时，有区别，当前台线程都运行结束后，后台线程会自动结束。
        join():什么意思？等待该线程结束。当A线程执行到了B的.join方法时，A就会处于冻结状态。
        A什么时候运行呢？当B运行结束后，A就会具备运行资格，继续运行。
        加入线程，可以完成对某个线程的临时加入执行
进程：正在执行的程序。
线程：是进程中用于控制程序执行的控制单元(执行路径，执行情景)
进程中至少有一个线程。
对于JVM，启动时，只好有两个线程：jvm的主线程。jvm的垃圾回收线程。
如何在程序中自定义线程呢？
Java给我们提供了对象线程这类事物的描述。该类是Thread
该类中定义了，
创建线程对象的方法(构造函数).
提供了要被线程执行的代码存储的位置（run()）
还定义了开启线程运行的方法(start()).
同时还有一些其他的方法用于操作线程：
        static Thread currentThead():
        String getName():
        static void sleep(time)throws InterruptedException:
要运行的代码都是后期定义的。
所以创建线程的第一种方式是：继承Thread类。原因：要覆盖run方法，定义线程要运行的代码。
步骤：
1，继承Thread类。
2，覆盖run方法。将线程要运行的代码定义其中。
3，创建Thread类的子类对象，其实就是在创建线程，调用start方法。
如果自定义的类中有多线程要运行的代码。但是该类有自己的父类。
那么就不可以在继承Thread。怎么办呢？
Java给我们提供了一个规则。Runnable接口。
如果自定义类不继承Thread，也可以实现Runnable接口。并将多线程要运行的代码存放在Runnable的run方法中。
这样多线程也可以帮助该类运行。
这样的操作有一个好处：避免了单继承的局限性。
创建线程的第二种方式：实现Runnable接口。
步骤：
1，定义了实现Runnable接口的类。
2，覆盖接口的run方法。将多线程要运行的代码存入其中。
3，创建Thread类的对象(创建线程),并将Runnable接口的子类对象作为参数传递给Thread的构造函数。
        为什么要传递？
因为线程要运行的代码都在Runnable子类的run方法中存储。所以要将该run方法所属的对象
        传递给Thread。让Thread线程去使用该对象调用其run方法。
4，调用Thread对象的start方法。开启线程。
两种方式的特点：
实现方式，因为避免了单继承的局限性，所以创建线程建议使用第二种方式。
线程的状态。
1，被创建。
2，运行。
3，冻结。
4，消亡。
其实还有一种特殊的状态：临时状态。
该临时状态的特点：
具备了执行资格，但不具备执行权。
冻结状态的特点：
放弃了执行资格。
多线程具备随机性。因为是由cpu不断的快速切换造成的。
就有可能会产生多线程的安全问题。
问题的产生的原因：
几个关键点：
1，多线程代码中有操作共享数据。
2，多条语句操作该共享数据。
当具备两个关键点时，
有一个线程对多条操作共享数据的代码执行的一部分。还没有执行完，另一个线程开始参与执行。
就会发生数据错误。
解决方法：
当一个线程在执行多条操作共享数据代码时，其他线程即使获取了执行权，也不可以参与操作。
Java就对这种解决方式提供了专业的代码。
同步
同步的原理：就是将部分操作功能数据的代码进行加锁
示例：火车上的卫生间。
同步的表现形式：
1，同步代码块。
2，同步函数。
两者有什么不同：
同步代码块使用的锁是任意对象。
同步函数使用的锁是this。
注意：对于static的同步函数，使用的锁不是this。是 类名.class 是该类的字节码文件对象。
        涉及到了单例设计模式的懒汉式。
同步的好处：解决了线程的安全问题。
弊端：
        较为消耗资源。
        同步嵌套后，容易死锁。
要记住：同步使用的前提：
        1，必须是两个或者两个以上的线程。
        2，必须是多个线程使用同一个锁。
        这是才可以称为这些线程被同步了。
六、暴力反射：
   在java中有一种特殊的反射机制，被叫做暴力反射。
Java中有许多的方法和对象为了安全考虑，都被封装在类中。通常这些私有的方法和对象都只能在该类的内部进行调用，对于外部的类来说，都是隐藏的，不可见的。为了能够在外部类中获取和操作这些私有的对象和方法，就可以使用暴力反射的方式来实现。

package apistudy;

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

/*
* 用反射获取构造方法
* */
public class ReflectDome1 {

        public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
                // TODO Auto-generated method stub
                //获取class文件
                Class<Person> c=(Class<Person>) Class.forName("apistudy.Person");
               
                //获取构造方法
                //public Constructor[] getConstructors()获取公共的构造（public修饰的）
                //public Constructor[] getDeclaredConstructors()获取所有的构造
        //Constructor<?>[] cons=c.getConstructors();
                // Constructor<?>[] cons=c.getDeclaredConstructors();
                // for(Constructor<?> con:cons){
                // System.out.println(con);
                // }
               
               
                //获取无参构造方法
                //public Constructor getConstrctor(Class<?>...parameterType)   三个点表示可变参数长度
                //参数表示的是：获取的构造方法的参数个数及其类型的class字节码文件中的对象
                Constructor con=c.getConstructor();//返回一个构造器
                //public T newIns0tance(Object...initargs)
                //使用Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例
                Object obj=con.newInstance();
                System.out.println(obj);
               
                //获取带参数的构造
                Constructor con1=c.getConstructor(String.class,int.class);
                obj=con1.newInstance("Jrt",23);
                System.out.println(obj);               
                暴力反射的体现
                //获取私有构造方法
                Constructor conPrivate=c.getDeclaredConstructor(String.class);
                //可以看出有了反射技术后，private不再是那么神秘了
                conPrivate.setAccessible(true);//设置该私有构造方法的权限是可访问
                //如果不设置可访问权限的话会抛出NoSuchMethodException, IllegalArgumentException
                obj=conPrivate.newInstance("jiangrongtao");
                System.out.println(obj);
        }

}

五、多线程间通信。
        等待/唤醒机制。
        也就是常见的生产者消费者问题。

        1.当多个生产者消费者出现时，
        需要让获取执行权的线程判断标记。
        通过while完成。
        2.需要将对方的线程唤醒。
        仅仅用notify，是不可以的。因为有可能出现只唤醒本方。
        有可能会导致，所有线程都等待。
        所以可以通过notifyAll的形式来完成 。
这个程序有一个bug。就是每次notifyAll。都会唤醒本方。
可不可以只唤醒对方呢？
JDK1.5版本提供了一些新的对象，优化了等待唤醒机制。
1，将synchronized 替换成了Lock接口。
        将隐式锁，升级成了显示锁。
        Lock
                获取锁：lock();
                释放锁：unlock();注意：释放的动作一定要执行，所以通常定义在finally中。
                获取Condition对象：newCondition();
2，将Object中的wait，notify，notifyAll方法都替换成了Condition的await，signal，signalAll。
和以前不同是：一个同步代码块具备一个锁，该所以具备自己的独立wait和notify方法。
现在是将wait，notify等方法，封装进一个特有的对象Condition，而一个Lock锁上可以有多个Condition对象。

        Lock lock = new ReentrantLock();
        Condition conA = lock.newCondition();
        Condition conB = lock.newCondition();
        con.await();//生产，，消费
        con.signal();生产
        set()
        {
                if(flag)
                        conA.await();//生产者，
                code......;

                flag = true;
                conB.signal();
        }
        out()
        {
                if(!flag)
                        conB.await();//消费者

                code....;
                flag = false;
                conA.signal();
        }
wait和sleep的区别：
wait:释放cpu执行权，释放同步中锁。
sleep:释放cpu执行权，不释放同步中锁。
synchronized(锁)
{
        wait();
}

停止线程：
        stop过时。
        原理：run方法结束。run方法中通常定义循环，指定控制住循环线程即可结束。

        1，定义结束标记。
        2，当线程处于了冻结状态，没有执行标记，程序一样无法结束。
                这时可以循环，正常退出冻结状态，或者强制结束冻结状态。
                强制结束冻结状态：interrupt();目的是线程强制从冻结状态恢复到运行状态。
                但是会发生InterruptedException异常。
线程中一些常见方法：
        setDaemon(boolean):将线程标记为后台线程，后台线程和前台线程一样，开启，一样抢执行权运行，
        只有在结束时，有区别，当前台线程都运行结束后，后台线程会自动结束。
        join():什么意思？等待该线程结束。当A线程执行到了B的.join方法时，A就会处于冻结状态。
        A什么时候运行呢？当B运行结束后，A就会具备运行资格，继续运行。
        加入线程，可以完成对某个线程的临时加入执行
进程：正在执行的程序。
线程：是进程中用于控制程序执行的控制单元(执行路径，执行情景)
进程中至少有一个线程。
对于JVM，启动时，只好有两个线程：jvm的主线程。jvm的垃圾回收线程。
如何在程序中自定义线程呢？
Java给我们提供了对象线程这类事物的描述。该类是Thread
该类中定义了，
创建线程对象的方法(构造函数).
提供了要被线程执行的代码存储的位置（run()）
还定义了开启线程运行的方法(start()).
同时还有一些其他的方法用于操作线程：
        static Thread currentThead():
        String getName():
        static void sleep(time)throws InterruptedException:
要运行的代码都是后期定义的。
所以创建线程的第一种方式是：继承Thread类。原因：要覆盖run方法，定义线程要运行的代码。
步骤：
1，继承Thread类。
2，覆盖run方法。将线程要运行的代码定义其中。
3，创建Thread类的子类对象，其实就是在创建线程，调用start方法。
如果自定义的类中有多线程要运行的代码。但是该类有自己的父类。
那么就不可以在继承Thread。怎么办呢？
Java给我们提供了一个规则。Runnable接口。
如果自定义类不继承Thread，也可以实现Runnable接口。并将多线程要运行的代码存放在Runnable的run方法中。
这样多线程也可以帮助该类运行。
这样的操作有一个好处：避免了单继承的局限性。
创建线程的第二种方式：实现Runnable接口。
步骤：
1，定义了实现Runnable接口的类。
2，覆盖接口的run方法。将多线程要运行的代码存入其中。
3，创建Thread类的对象(创建线程),并将Runnable接口的子类对象作为参数传递给Thread的构造函数。
        为什么要传递？
因为线程要运行的代码都在Runnable子类的run方法中存储。所以要将该run方法所属的对象
        传递给Thread。让Thread线程去使用该对象调用其run方法。
4，调用Thread对象的start方法。开启线程。
两种方式的特点：
实现方式，因为避免了单继承的局限性，所以创建线程建议使用第二种方式。
线程的状态。
1，被创建。
2，运行。
3，冻结。
4，消亡。
其实还有一种特殊的状态：临时状态。
该临时状态的特点：
具备了执行资格，但不具备执行权。
冻结状态的特点：
放弃了执行资格。
多线程具备随机性。因为是由cpu不断的快速切换造成的。
就有可能会产生多线程的安全问题。
问题的产生的原因：
几个关键点：
1，多线程代码中有操作共享数据。
2，多条语句操作该共享数据。
当具备两个关键点时，
有一个线程对多条操作共享数据的代码执行的一部分。还没有执行完，另一个线程开始参与执行。
就会发生数据错误。
解决方法：
当一个线程在执行多条操作共享数据代码时，其他线程即使获取了执行权，也不可以参与操作。
Java就对这种解决方式提供了专业的代码。
同步
同步的原理：就是将部分操作功能数据的代码进行加锁
示例：火车上的卫生间。
同步的表现形式：
1，同步代码块。
2，同步函数。
两者有什么不同：
同步代码块使用的锁是任意对象。
同步函数使用的锁是this。
注意：对于static的同步函数，使用的锁不是this。是 类名.class 是该类的字节码文件对象。
        涉及到了单例设计模式的懒汉式。
同步的好处：解决了线程的安全问题。
弊端：
        较为消耗资源。
        同步嵌套后，容易死锁。
要记住：同步使用的前提：
        1，必须是两个或者两个以上的线程。
        2，必须是多个线程使用同一个锁。
        这是才可以称为这些线程被同步了。
六、暴力反射：
   在java中有一种特殊的反射机制，被叫做暴力反射。
Java中有许多的方法和对象为了安全考虑，都被封装在类中。通常这些私有的方法和对象都只能在该类的内部进行调用，对于外部的类来说，都是隐藏的，不可见的。为了能够在外部类中获取和操作这些私有的对象和方法，就可以使用暴力反射的方式来实现。

package apistudy;

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

/*
* 用反射获取构造方法
* */
public class ReflectDome1 {

        public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
                // TODO Auto-generated method stub
                //获取class文件
                Class<Person> c=(Class<Person>) Class.forName("apistudy.Person");
               
                //获取构造方法
                //public Constructor[] getConstructors()获取公共的构造（public修饰的）
                //public Constructor[] getDeclaredConstructors()获取所有的构造
        //Constructor<?>[] cons=c.getConstructors();
                // Constructor<?>[] cons=c.getDeclaredConstructors();
                // for(Constructor<?> con:cons){
                // System.out.println(con);
                // }
               
               
                //获取无参构造方法
                //public Constructor getConstrctor(Class<?>...parameterType)   三个点表示可变参数长度
                //参数表示的是：获取的构造方法的参数个数及其类型的class字节码文件中的对象
                Constructor con=c.getConstructor();//返回一个构造器
                //public T newIns0tance(Object...initargs)
                //使用Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例
                Object obj=con.newInstance();
                System.out.println(obj);
               
                //获取带参数的构造
                Constructor con1=c.getConstructor(String.class,int.class);
                obj=con1.newInstance("Jrt",23);
                System.out.println(obj);               
                暴力反射的体现
                //获取私有构造方法
                Constructor conPrivate=c.getDeclaredConstructor(String.class);
                //可以看出有了反射技术后，private不再是那么神秘了
                conPrivate.setAccessible(true);//设置该私有构造方法的权限是可访问
                //如果不设置可访问权限的话会抛出NoSuchMethodException, IllegalArgumentException
                obj=conPrivate.newInstance("jiangrongtao");
                System.out.println(obj);
        }

}