* (2)懒汉式 面试写这种方式。多线程的问题？
        *
                        //懒汉式,单例的延迟加载模式
                        class Singleton {
                                //1,私有构造函数
                                private Singleton(){}
                                //2,创建本类对象
                                private static Singleton s;
                                //3,对外提供公共的访问方法
                                public static Singleton getInstance() {
                                        if(s == null)
                                                //线程1,线程2
                                                s = new Singleton();
                                        return s;
                                }
                               
                                public static void print() {
                                        System.out.println("11111111111");
                                }
                        }
        * (3)第三种格式
        *
                        class Singleton {
                                private Singleton() {}
                       
                                public static final Singleton s = new Singleton();//final是最终的意思,被final修饰的变量不可以被更改
                        }
        * Runtime类是一个单例类
        *
                        Runtime r = Runtime.getRuntime();
                        //r.exec("shutdown -s -t 300");                //300秒后关机
                        r.exec("shutdown -a");                                //取消关机
        * Timer类:计时器

                        public class Demo5_Timer {
                                /**
                                 * @param args
                                 * 计时器
                                 * @throws InterruptedException
                                 */
                                public static void main(String[] args) throws InterruptedException {
                                        Timer t = new Timer();
                                        t.schedule(new MyTimerTask(), new Date(114,9,15,10,54,20),3000);
                                       
                                        while(true) {
                                                System.out.println(new Date());
                                                Thread.sleep(1000);
                                        }
                                }
                        }
                        class MyTimerTask extends TimerTask {
                                @Override
                                public void run() {
                                        System.out.println("起床背英语单词");
                                }
                               
                        }

###三.线程之间的通信
* 1.什么时候需要通信
        * 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
        * 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
* 2.怎么通信
        * 如果希望线程等待, 就调用wait()
        * 如果希望唤醒等待的线程, 就调用notify();
        * 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用
* 3.多个线程通信的问题
        * notify()方法是随机唤醒一个线程
        * notifyAll()方法是唤醒所有线程
        * JDK5之前无法唤醒指定的一个线程
        * 如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件
       
###四.JDK5之后的线程控制
* 1.同步
        * 使用ReentrantLock类的lock()和unlock()方法进行同步
* 2.通信
        * 使用ReentrantLock类的newCondition()方法可以获取Condition对象
        * 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
        * 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了
###五.同步与非同步类的总结
* StringBuffer和StringBuilder,StringBuffer是线程安全的,效率低,StringBuilder是线程不安全的,效率高
* Vector和ArrayList,Vector是线程安全的,效率低,ArrayList是线程不安全的,效率高
* Hashtable和HashMap,Hashtable是线程安全的,效率低,HashMap是线程不安全的,效率高
###六.GUI
* 1.事件处理
        * 用户的一个操作就是一个事件, 事件处理就是在事件发生的时候程序做出什么反应
        * 事件发生在哪个组件上, 哪个组件就是事件源
        * 给事件源添加一个监听器对象
        * 监听器对象中包含若干事件处理方法
        * 如果事件发生了, 事件处理方法就会自动执行

* 2.适配器
        * a.什么是适配器
                * 在使用监听器的时候, 需要定义一个类事件监听器接口.
                * 通常接口中有多个方法, 而程序中不一定所有的都用到, 但又必须重写, 这很繁琐.
                * 适配器简化了这些操作, 我们定义监听器时只要继承适配器, 然后重写需要的方法即可.
        * b.适配器原理
                * 适配器就是一个类, 实现了监听器接口, 所有抽象方法都重写了, 但是方法全是空的.
                * 目的就是为了简化程序员的操作, 定义监听器时继承适配器, 只重写需要的方法就可以了.
       
###七.GUI重点
* 1.事件处理
        * 事件: 用户的一个操作
        * 事件源: 被操作的组件
        * 监听器: 一个自定义类的对象, 实现了监听器接口, 包含事件处理方法
        * 把监听器添加在事件源上, 当事件发生的时候虚拟机就会自动调用监听器中的事件处理方法

总结的不错啊！