java基础学习_多线程02_多线程、设计模式_day24总结

java基础学习_多线程02_多线程、设计模式_day24总结

=============================================================================
=============================================================================
涉及到的知识点有：
    1:多线程(理解)
        (1)JDK5中Lock锁的使用
        (2)Lock接口的方法
        (3)死锁问题的描述和代码体现
        (4)生产者和消费者多线程体现(线程间通信问题)
        (5)线程的状态转换图及常见的线程执行情况
        (6)线程组
        (7)线程池
        (8)多线程实现的第三种方案：依赖于线程池而存在的
        (9)匿名内部类方式使用多线程
        (10)定时器
        (11)多线程常见的面试题
    2:设计模式(理解)
        (1)面向对象思想的设计原则的概述
        (2)设计模式
        (3)常见的设计模式
        (4)Runtime类的概述和应用
=============================================================================
=============================================================================
1:多线程(理解)
    (1)JDK5中Lock锁的使用
        虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
        为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock接口。
        即：JDK5以后的针对线程的锁定操作和释放操作。
        Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。
    (2)Lock接口的方法
        void lock()        获取锁(加锁)
        void unlock()      释放锁
        
        ReentrantLock类是Lock接口的实现类。
        示例代码如下：

package cn.itcast_01;
/*
 * 虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
 * 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock接口。
 * 
 * Lock接口的方法：
 *         void lock() 获取锁(加锁)
 *         void unlock() 释放锁
 * 
 * ReentrantLock类是Lock接口的实现类。
 */
public class SellTicketDemo {
    public static void main(String[] args) {
        // 创建资源对象
        SellTicket st = new SellTicket();

        // 创建三个线程对象
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

package cn.itcast_01;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SellTicket implements Runnable {
    // 定义票
    private int tickets = 100;

    // 定义锁对象
    private Lock lock = new ReentrantLock(); // 多态

    @Override
    public void run() {
        while (true) {
            // 如果锁里面有异常发生，释放锁lock.unlock();就不会被执行，
            // 为了保证释放锁lock.unlock();被执行，使用try...finally...
            // 将lock.unlock();放在finally里面。
            try {
                // 获取锁(加锁)
                lock.lock();
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets--) + "张票");
                }
            } finally {
                // 释放锁
                lock.unlock();
            }
        }
    }

}

--------------------------------------
    (3)死锁问题的描述和代码体现
        同步弊端：效率低；如果出现了同步嵌套，就容易产生死锁问题。
        死锁问题：是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象。
        同步代码块的嵌套案例代码如下：

package cn.itcast_02;

public class MyLock {
    // 创建两把锁对象
    public static final Object objA = new Object();
    public static final Object objB = new Object();
}

package cn.itcast_02;

public class DieLock extends Thread {

    private boolean flag;

    public DieLock(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if (flag) {
            synchronized (MyLock.objA) {
                System.out.println("if objA");
                synchronized (MyLock.objB) {
                    System.out.println("if objB");
                }
            }
        } else {
            synchronized (MyLock.objB) {
                System.out.println("else objB");
                synchronized (MyLock.objA) {
                    System.out.println("else objA");
                }
            }
        }
    }
    
}

package cn.itcast_02;

/*
 * 同步的弊端：
 *         A:效率低
 *         B:如果出现了同步嵌套，就容易产生死锁问题
 * 
 * 死锁：
 *         是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象。
 * 
 * 举例：
 *         中国人和美国人一起吃饭案例。
 *         正常情况：
 *             中国人:筷子两支
 *             美国人:刀和叉
 *         现在：
 *             中国人：筷子1支，刀一把
 *             美国人：筷子1支，叉一把
 */
public class DieLockDemo {
    public static void main(String[] args) {
        DieLock dl1 = new DieLock(true);
        DieLock dl2 = new DieLock(false);

        dl1.start();
        dl2.start();
    }
}

--------------------------------------        
    (4)生产者和消费者多线程体现(线程间通信问题)
        线程间通信：针对同一个资源的操作有不同种类的线程。
            举例：卖票有进的，也有出的。    
            
        通过设置线程(生产者)和获取线程(消费者)针对同一个学生对象进行操作。

        
        以学生作为资源来实现的。
        
        学生资源类：Student
        设置学生数据线程类：SetThread(生产者)
        获取学生数据线程类：GetThread(消费者)
        测试类：StudentDemo
        
        代码：
            A:最基本的版本，只有一个数据。
            B:改进版本，给出了不同的数据，并加入了同步机制。
            C:等待唤醒机制改进该程序，让数据能够实现依次的出现。
                wait()
                notify()    (用在单个生产线程和单个消费线程)
                notifyAll() (用在多个生产线程和多个消费线程)
            D:等待唤醒机制的代码优化。把数据和操作都写在了学生资源类中。

A版本代码如下：

package cn.itcast_03;

public class Student {
    String name;
    int age;
}

package cn.itcast_03;

public class SetThread implements Runnable {

    private Student s;

    // 带参构造
    public SetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        // Student s = new Student();
        s.name = "林青霞";
        s.age = 27;
    }

}

package cn.itcast_03;

public class GetThread implements Runnable {
    
    private Student s;

    // 带参构造
    public GetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        // Student s = new Student();
        System.out.println(s.name + "---" + s.age);
    }

}

package cn.itcast_03;

/*
 * 分析：
 *         学生资源类：Student    
 *         设置学生数据线程类：SetThread(生产者)
 *         获取学生数据线程类：GetThread(消费者)
 *         测试类:StudentDemo
 * 
 * 问题1：按照思路写代码，发现数据每次都是:null---0
 * 原因：
 *         我们在每个线程中都创建了新的资源：Student s = new Student();
 *         而我们要求的是：设置和获取线程的资源应该是同一个。
 * 如何解决呢?
 *         如何把一个数据在多个类中共享使用呢？
 *         思路1：在外界把这个数据创建出来，通过构造方法传递给其他的类。
 * 
 */
public class StudentDemo {
    public static void main(String[] args) {
        // 创建资源对象
        Student s = new Student();
        
        // 创建设置和获取对象，并把资源对象作为构造方法的参数进行传递
        SetThread st = new SetThread(s);
        GetThread gt = new GetThread(s);

        // 创建线程对象
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);

        // 启动线程
        t1.start();
        t2.start();
    }
}

B版本代码如下：

package cn.itcast_04;

public class Student {
    String name;
    int age;
}

package cn.itcast_04;

public class SetThread implements Runnable {
    private int x = 0;

    private Student s;

    // 带参构造
    public SetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (s) {
                if (x % 2 == 0) {
                    s.name = "林青霞"; // 刚走到这里，就被别人抢到了执行权
                    s.age = 27;
                } else {
                    s.name = "刘意"; // 刚走到这里，就被别人抢到了执行权
                    s.age = 30;
                }
                x++;
            }
        }
    }

}

package cn.itcast_04;

public class GetThread implements Runnable {
    
    private Student s;
    
    // 带参构造
    public GetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (s) {
                System.out.println(s.name + "---" + s.age);
            }
        }
    }

}

package cn.itcast_04;

/*
 * 分析：
 *         学生资源类：Student    
 *         设置学生数据线程类：SetThread(生产者)
 *         获取学生数据线程类：GetThread(消费者)
 *         测试类:StudentDemo
 * 
 * 问题1：按照思路写代码，发现数据每次都是:null---0
 * 原因：
 *         我们在每个线程中都创建了新的资源：Student s = new Student();
 *         而我们要求的是：设置和获取线程的资源应该是同一个。
 * 如何解决呢?
 *         如何把一个数据在多个类中共享使用呢？
 *         思路1：在外界把这个数据创建出来，通过构造方法传递给其他的类。
 * 
 * 
 * 问题2：为了数据的效果好一些，我加入了循环和判断，给出不同的值，这个时候产生了新的问题
 *         A:同一个数据出现多次
 *         B:姓名和年龄不匹配
 * 原因：
 *         A:同一个数据出现多次
 *             CPU的一点点时间片的执行权，就足够你执行很多次。
 *         B:姓名和年龄不匹配
 *             线程运行的随机性
 * 线程安全问题：
 *         A:是否是多线程环境            是
 *         B:是否有共享数据            是
 *         C:是否有多条语句操作共享数据    是
 * 解决方案：
 *         加锁。
 *         注意：
 *             A:不同种类的线程都要加锁。
 *             B:不同种类的线程加的锁必须是同一把。
 */
public class StudentDemo {
    public static void main(String[] args) {
        // 创建资源对象
        Student s = new Student();
        
        // 创建设置和获取对象，并把资源对象作为构造方法的参数进行传递
        SetThread st = new SetThread(s);
        GetThread gt = new GetThread(s);

        // 创建线程对象
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);

        // 启动线程
        t1.start();
        t2.start();
    }
}

C版本代码如下：

package cn.itcast_05;

public class Student {
    String name;
    int age;
    boolean flag; // flag默认值是false，我们标记为没有数据；如果flag是true，我们标记为有数据
}

package cn.itcast_05;

public class SetThread implements Runnable {
    
    private int x = 0;

    private Student s;

    // 带参构造
    public SetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (s) {
                // 生产者判断有没有数据
                
                // 有数据就等着消费者先消费数据
                if (s.flag) {
                    try {
                        s.wait(); // t1等待，wait()方法的特点：1.线程等待并立即释放锁。2.线程将来醒过来的时候，是从这里醒过来的。
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
    
                // 没有数据就生产数据
                if (x % 2 == 0) {
                    s.name = "林青霞";
                    s.age = 27;
                } else {
                    s.name = "刘意";
                    s.age = 30;
                }
                x++;
    
                // 程序能执行到这里，说明数据生产出来了
                s.flag = true; // 修改标记，通知消费者消费数据
                
                // 唤醒线程(唤醒消费者)
                s.notify(); // 唤醒t2，唤醒并不表示立马就可以执行，必须还得抢CPU的执行权
            } 
        }
    }
    
}

package cn.itcast_05;

public class GetThread implements Runnable {
    
    private Student s;
    
    // 带参构造
    public GetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (s) {
                // 消费者判断有没有数据
                
                // 没有数据就等着生产者先生产数据
                if (!s.flag) {
                    try {
                        s.wait(); // t2等待，wait()方法的特点：1.线程等待并立即释放锁。2.线程将来醒过来的时候，是从这里醒过来的。
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                
                // 有数据就消费
                System.out.println(s.name + "---" + s.age);
                
                // 程序能执行到这里，说明数据消费完了
                s.flag = false; // 修改标记，通知生产者生产数据
                
                // 唤醒线程(唤醒生产者)
                s.notify(); // 唤醒t1，唤醒并不表示立马就可以执行，必须还得抢CPU的执行权
            }
        }
    }
    
}

package cn.itcast_05;

/*
 * 分析：
 *         学生资源类：Student    
 *         设置学生数据线程类：SetThread(生产者)
 *         获取学生数据线程类：GetThread(消费者)
 *         测试类:StudentDemo
 * 
 * 问题1：按照思路写代码，发现数据每次都是:null---0
 * 原因：
 *         我们在每个线程中都创建了新的资源：Student s = new Student();
 *         而我们要求的是：设置和获取线程的资源应该是同一个。
 * 如何解决呢?
 *         如何把一个数据在多个类中共享使用呢？
 *         思路1：在外界把这个数据创建出来，通过构造方法传递给其他的类。
 * 
 * 
 * 问题2：为了数据的效果好一些，我加入了循环和判断，给出不同的值，这个时候产生了新的问题
 *         A:同一个数据出现多次
 *         B:姓名和年龄不匹配
 * 原因：
 *         A:同一个数据出现多次
 *             CPU的一点点时间片的执行权，就足够你执行很多次。
 *         B:姓名和年龄不匹配
 *             线程运行的随机性
 * 线程安全问题：
 *         A:是否是多线程环境            是
 *         B:是否有共享数据            是
 *         C:是否有多条语句操作共享数据    是
 * 解决方案：
 *         加锁。
 *         注意：
 *             A:不同种类的线程都要加锁。
 *             B:不同种类的线程加的锁必须是同一把。
 * 
 * 
 * 问题3：虽然数据安全了，但是呢，一次输出一大片不好看，我就想依次的一次一个输出。
 * 如何解决呢?
 *         通过Java提供的等待唤醒机制解决。
 * 等待唤醒：
 *         Object类中提供了三个方法：
 *             public final wait() 等待
 *             public final notify() 唤醒单个线程(用在单个生产线程和单个消费线程)
 *             public final notifyAll() 唤醒所有线程(用在多个生产线程和多个消费线程)
 *         为什么这些方法不定义在Thread类中呢?
 *             这些方法的调用必须通过锁对象调用，而我们刚才使用的是同步代码块，其锁对象是任意对象。
 *             所以，这些方法定义在Object类中。
 */
public class StudentDemo {
    public static void main(String[] args) {
        // 创建资源对象
        Student s = new Student();
        
        // 创建设置和获取对象，并把资源对象作为构造方法的参数进行传递
        SetThread st = new SetThread(s);
        GetThread gt = new GetThread(s);

        // 创建线程对象
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);

        // 启动线程
        t1.start();
        t2.start();
    }
}

D版本代码如下：

package cn.itcast_07;

public class Student {
    private String name;
    private int age;
    private boolean flag; // flag默认值是false，我们标记为没有数据；如果flag是true，我们标记为有数据

    public synchronized void set(String name, int age) {
        // 生产者判断有没有数据
        // 有数据就等着消费者先消费数据
        if (this.flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 没有数据就生产数据
        this.name = name;
        this.age = age;

        // 程序能执行到这里，说明数据生产出来了
        this.flag = true; // 修改标记，通知消费者消费数据
        this.notify(); // 唤醒t2，唤醒并不表示立马就可以执行，必须还得抢CPU的执行权
    }

    public synchronized void get() {
        // 消费者判断有没有数据
        // 没有数据就等着生产者先生产数据
        if (!this.flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 有数据就消费
        System.out.println(this.name + "---" + this.age);

        // 程序能执行到这里，说明数据消费完了
        this.flag = false; // 修改标记，通知生产者生产数据
        this.notify(); // 唤醒t1，唤醒并不表示立马就可以执行，必须还得抢CPU的执行权
    }
}

package cn.itcast_07;

public class SetThread implements Runnable {
    
    private int x = 0;

    private Student s;

    // 带参构造
    public SetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            if (x % 2 == 0) {
                s.set("林青霞", 27);
            } else {
                s.set("刘意", 30);
            }
            x++;
        } 
    }
    
}
    

package cn.itcast_07;

public class GetThread implements Runnable {
    
    private Student s;
    
    // 带参构造
    public GetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            s.get();
        }
    }
    
}

package cn.itcast_07;

/*
 * 分析：
 *         学生资源类：Student    
 *         设置学生数据线程类：SetThread(生产者)
 *         获取学生数据线程类：GetThread(消费者)
 *         测试类:StudentDemo
 * 
 * 问题1：按照思路写代码，发现数据每次都是:null---0
 * 原因：
 *         我们在每个线程中都创建了新的资源：Student s = new Student();
 *         而我们要求的是：设置和获取线程的资源应该是同一个。
 * 如何解决呢?
 *         如何把一个数据在多个类中共享使用呢？
 *         思路1：在外界把这个数据创建出来，通过构造方法传递给其他的类。
 * 
 * 
 * 问题2：为了数据的效果好一些，我加入了循环和判断，给出不同的值，这个时候产生了新的问题
 *         A:同一个数据出现多次
 *         B:姓名和年龄不匹配
 * 原因：
 *         A:同一个数据出现多次
 *             CPU的一点点时间片的执行权，就足够你执行很多次。
 *         B:姓名和年龄不匹配
 *             线程运行的随机性
 * 线程安全问题：
 *         A:是否是多线程环境            是
 *         B:是否有共享数据            是
 *         C:是否有多条语句操作共享数据    是
 * 解决方案：
 *         加锁。
 *         注意：
 *             A:不同种类的线程都要加锁。
 *             B:不同种类的线程加的锁必须是同一把。
 * 
 * 
 * 问题3：虽然数据安全了，但是呢，一次输出一大片不好看，我就想依次的一次一个输出。
 * 如何解决呢?
 *         通过Java提供的等待唤醒机制解决。
 * 等待唤醒：
 *         Object类中提供了三个方法：
 *             public final wait() 等待
 *             public final notify() 唤醒单个线程
 *             public final notifyAll() 唤醒所有线程
 *         为什么这些方法不定义在Thread类中呢?
 *             这些方法的调用必须通过锁对象调用，而我们刚才使用的是同步代码块，其锁对象是任意对象。
 *             所以，这些方法定义在Object类中。
 *
 *
 * 最终版代码中：
 *         把Student的成员变量给私有了。
 *         把设置和获取的操作给封装成了功能，并加了同步(同步方法)。
 *         设置或获取线程类里面只需要调用方法即可。
 */
public class StudentDemo {
    public static void main(String[] args) {
        // 创建资源对象
        Student s = new Student();
        
        // 创建设置和获取对象，并把资源对象作为构造方法的参数进行传递
        SetThread st = new SetThread(s);
        GetThread gt = new GetThread(s);

        // 创建线程对象
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);

        // 启动线程
        t1.start();
        t2.start();
    }
}

--------------------------------------
    (5)线程的状态转换图及常见的线程执行情况

    (6)线程组
        Java中使用ThreadGroup类来表示线程组类，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
        默认情况下，所有的线程都属于主线程组。

package cn.itcast_06;

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int x = 0; x < 100; x++) {
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }
    }

}

package cn.itcast_06;

/*
 * 线程组： 把多个线程组合到一起。
 * 
 *         它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
 */
public class ThreadGroupDemo {
    public static void main(String[] args) {
        // method1();

        // 我们如何修改线程所在的组呢?
        // 创建一个线程组，在创建其他线程的时候，把其他线程的组指定为我们自己新建线程组
        method2();
    }

    private static void method2() {
        // 线程组类ThreadGroup的构造方法：public ThreadGroup(String name)
        ThreadGroup tg = new ThreadGroup("新的线程组");
        MyRunnable my = new MyRunnable();
        
        // 线程类Thread的构造方法：public Thread(ThreadGroup group, Runnable target, String name)
        Thread t1 = new Thread(tg, my, "林青霞");
        Thread t2 = new Thread(tg, my, "刘意");
        
        System.out.println(t1.getThreadGroup().getName()); // 新的线程组
        System.out.println(t2.getThreadGroup().getName()); // 新的线程组
        
        // 通过线程组组名去设置后台线程，表示该组的线程都是后台线程(守护线程)，不用一个一个线程去设置了，多简洁
        tg.setDaemon(true);
    }

    private static void method1() {
        MyRunnable my = new MyRunnable();
        Thread t1 = new Thread(my, "林青霞");
        Thread t2 = new Thread(my, "刘意");
        // 我不知道上面的线程属于那个线程组，我想知道，肿么办?
        
        // 线程类Thread里面的方法：public final ThreadGroup getThreadGroup() 返回该线程所属的线程组
        ThreadGroup tg1 = t1.getThreadGroup();
        ThreadGroup tg2 = t2.getThreadGroup();
        
        // 线程组类ThreadGroup里面的方法：public final String getName() 返回此线程组的名称
        String name1 = tg1.getName();
        String name2 = tg2.getName();
        System.out.println(name1); // main
        System.out.println(name2); // main
        // 通过结果我们知道了：线程默认情况下属于main线程组
        
        // 通过下面的测试，你应该能够看到，默任情况下，所有的线程都属于同一个组
        System.out.println(Thread.currentThread().getThreadGroup().getName()); // 链式编程
    }
}

    (7)线程池
        程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。
        而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。
        
        线程池的特点：线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。
        
        问题：一开始线程池里面设计多少个线程才合适呢?
            答：需要我们进行压力测试、并发访问测试等。
            
        在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池。

package cn.itcast_08;

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int x = 0; x < 100; x++) {
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }
    }

}

package cn.itcast_08;

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

/*
 * 程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。
 * 而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。
 * 
 * 线程池的好处：线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。
 * 
 * 在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池。
 * JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
 *         public static ExecutorService newCachedThreadPool() 创建一个具有缓存功能的线程池
 *         public static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用的，具有固定线程数的线程池
 *         public static ExecutorService newSingleThreadExecutor() 创建一个只有单线程的线程池，相当于上个方法的参数是1
 *         这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。
 * 
 * 如何实现线程池呢?
 *         A:创建一个线程池对象，明确在线程池中要创建几个线程对象。
 *             Executors类的方法：
 *                 public static ExecutorService newFixedThreadPool(int nThreads)
 *                 该方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。
 *         B:这种线程池的线程可以执行Runnable对象或者Callable对象代表的线程。
 *             即：做一个类实现Runnable接口。
 *         C:调用如下方法即可
 *             ExecutorService类的方法：
 *             Future<?> submit(Runnable task)
 *            <T> Future<T> submit(Callable<T> task)
 *        D:线程池中的线程使用完毕后，会自动回到线程池中成为空闲状态，等待下一个对象来使用。
 *            但是呢，我就要结束线程池，可以吗?
 *            可以。
 */
public class ExecutorsDemo {
    public static void main(String[] args) {
        // 创建一个线程池对象，明确在线程池中要创建几个线程对象
        // Executors类的方法：public static ExecutorService newFixedThreadPool(int nThreads)
        ExecutorService pool = Executors.newFixedThreadPool(2);

        // 这种线程池的线程可以执行Runnable对象或者Callable对象代表的线程
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());

        // 结束线程池
        pool.shutdown();
    }
}

--------------------------------------
    (8)多线程实现的第三种方案：依赖于线程池而存在的
        如何实现线程池呢?
        A:创建一个线程池对象，确定在线程池中要创建几个线程对象。
            Executors类的方法：
            　　public static ExecutorService newFixedThreadPool(int nThreads)
            　　该方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。
        B:这种线程池的线程可以执行Runnable对象或者Callable对象代表的线程。
            即：做一个类实现Runnable接口。
        C:调用如下方法即可
            ExecutorService类的方法：
            　　Future<?> submit(Runnable task)
            　　<T> Future<T> submit(Callable<T> task)
        D:线程池中的线程使用完毕后，会自动回到线程池中成为空闲状态，等待下一个对象来使用。
            但是呢，我就要结束线程池，可以吗?
            可以。
            
        好处：
            可以有返回值。
            可以抛出异常。
        弊端：
            代码比较复杂，而且依赖于线程池而存在的，所以一般不用它。

package cn.itcast_09;

import java.util.concurrent.Callable;

// Callable:是带泛型的接口。
// 这里指定的泛型其实是call()方法的返回值类型。
public class MyCallable implements Callable {

    @Override
    public Object call() throws Exception {
        for (int x = 0; x < 100; x++) {
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }
        return null;
    }

}

package cn.itcast_09;

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

/*
 * 多线程实现的方式3：依赖于线程池而存在的
 * 
 * 如何实现线程池呢?
 *         A:创建一个线程池对象，明确在线程池中要创建几个线程对象。
 *             Executors类的方法：
 *                 public static ExecutorService newFixedThreadPool(int nThreads)
 *                 该方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。
 *         B:这种线程池的线程可以执行Runnable对象或者Callable对象代表的线程。
 *             即：做一个类实现Runnable接口。
 *         C:调用如下方法即可
 *             ExecutorService类的方法：
 *             Future<?> submit(Runnable task)
 *            <T> Future<T> submit(Callable<T> task)
 *        D:线程池中的线程使用完毕后，会自动回到线程池中成为空闲状态，等待下一个对象来使用。
 *            但是呢，我就要结束线程池，可以吗?
 *            可以。
 */
public class CallableDemo {
    public static void main(String[] args) {
        // // 创建一个线程池对象，明确在线程池中要创建几个线程对象
        ExecutorService pool = Executors.newFixedThreadPool(2);
        
        // 这种线程池的线程可以执行Runnable对象或者Callable对象代表的线程
        pool.submit(new MyCallable());
        pool.submit(new MyCallable());
        
        // 结束线程池
        pool.shutdown();
    }
}

线程求和案例：用多线程实现的方式3

package cn.itcast_10;

import java.util.concurrent.Callable;

/*
 * 线程求和案例
 */
public class MyCallable implements Callable<Integer> {

    private int number;

    public MyCallable(int number) {
        this.number = number;
    }

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int x = 1; x <= number; x++) {
            sum += x;
        }
        return sum;
    }

}

package cn.itcast_10;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/*
 * 多线程实现的方式3：依赖于线程池而存在的
 * 
 * 如何实现线程池呢?
 *         A:创建一个线程池对象，明确在线程池中要创建几个线程对象。
 *             Executors类的方法：
 *                 public static ExecutorService newFixedThreadPool(int nThreads)
 *                 该方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。
 *         B:这种线程池的线程可以执行Runnable对象或者Callable对象代表的线程。
 *             即：做一个类实现Runnable接口。
 *         C:调用如下方法即可
 *             ExecutorService类的方法：
 *             Future<?> submit(Runnable task)
 *            <T> Future<T> submit(Callable<T> task)
 *        D:线程池中的线程使用完毕后，会自动回到线程池中成为空闲状态，等待下一个对象来使用。
 *            但是呢，我就要结束线程池，可以吗?
 *            可以。
 */
public class CallableDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 创建一个线程池对象，明确在线程池中要创建几个线程对象
        ExecutorService pool = Executors.newFixedThreadPool(2);

        // 这种线程池的线程可以执行Runnable对象或者Callable对象代表的线程
        Future<Integer> f1 = pool.submit(new MyCallable(100));
        Future<Integer> f2 = pool.submit(new MyCallable(200));

        // Future接口的方法：V get()
        Integer i1 = f1.get();
        Integer i2 = f2.get();

        System.out.println(i1);
        System.out.println(i2);

        // 结束线程池
        pool.shutdown();
    }
}

--------------------------------------
    (9)匿名内部类方式使用多线程
        在开发中，为了方便使用线程，需要随手开线程，最简单的做法就是采用匿名内部类方式使用多线程。
        匿名内部类的格式：
            new 类名或者接口名() {
                重写方法;
            }
            本质：是该类的子类对象或者该接口的实现类对象。
            new Thread() {代码...}.start();
            new Thread(new Runnable() {代码...}) {}.start();
            示例代码如下：

package cn.itcast_11;

/*
 * 匿名内部类的格式：
 *         new 类名或者接口名() {
 *             重写方法;
 *         }
 * 
 *         本质：是该类的子类对象或者该接口的实现类对象。
 */
public class ThreadDemo {
    public static void main(String[] args) {
        // 继承Thread类来实现多线程
        new Thread() {
            @Override
            public void run() {
                for (int x = 0; x < 100; x++) {
                    System.out.println(Thread.currentThread().getName() + ":" + x);
                }
            }
        }.start();

        // 实现Runnable接口来实现多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int x = 0; x < 100; x++) {
                    System.out.println(Thread.currentThread().getName() + ":" + x);
                }
            }
        }) {
        }.start();

        // 面试题
        // 到底执行的是Thread类的子类对象的run()，还是执行的是Runnable接口的实现类对象的run()呢？ 答：是Thread类的子类对象的run() world
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int x = 0; x < 100; x++) {
                    System.out.println("hello" + ":" + x);
                }
            }
        }) {
            @Override
            public void run() {
                for (int x = 0; x < 100; x++) {
                    System.out.println("world" + ":" + x);
                }
            }
        }.start();
        
    }
}

    (10)定时器
        定时器是一个应用十分广泛的线程工具，可用于调度多个定时任务以后台线程的方式执行。在Java中，可以通过Timer和TimerTask类来实现定义调度的功能。(在java.util包下)
        A:Timer(定时器类)
            public Timer()
            public void schedule(TimerTask?task, long?delay)
            public void schedule(TimerTask task, long delay, long period)
        B:TimerTask(任务抽象类)
            public abstract void run()
            public boolean cancel()
        C:在实际开发中
            Quartz是一个完全由java编写的开源调度框架。
        D:需求：在指定的时间删除我们的指定目录(演示：使用项目路径下的demo)

package cn.itcast_12;

import java.util.Timer;
import java.util.TimerTask;

/*
 * 定时器：可以让我们在指定的时间做某件事情，还可以重复的做某件事情。
 * 
 * 依赖Timer和TimerTask这两个类：
 * Timer(定时器类)
 *         public Timer()
 *         public void schedule(TimerTask task, long delay) 在指定延迟后执行指定的任务
 *         public void schedule(TimerTask task, long delay, long period)
 *         public void cancel()
 * 
 * TimerTask(任务抽象类)
 */
public class TimerDemo {
    public static void main(String[] args) {
        // 创建定时器对象
        Timer t = new Timer();
        
        // 3秒后执行爆炸任务
        // t.schedule(new MyTask(), 3000);
        
        // 3秒后执行爆炸任务，并结束任务
        t.schedule(new MyTask(t), 3000);
    }
}

// 做一个任务
class MyTask extends TimerTask {

    private Timer t;
    
    public MyTask(){}
    
    public MyTask(Timer t){
        this.t = t;
    }
    
    @Override
    public void run() {
        System.out.println("beng，爆炸了");
        t.cancel(); // 结束任务
    }

}

package cn.itcast_12;

import java.util.Timer;
import java.util.TimerTask;

/*
 * 定时器：可以让我们在指定的时间做某件事情，还可以重复的做某件事情。
 * 
 * 依赖Timer和TimerTask这两个类：
 * Timer(定时器类)
 *         public Timer()
 *         public void schedule(TimerTask task, long delay) 在指定延迟后执行指定的任务
 *         public void schedule(TimerTask task, long delay, long period)
 *         public void cancel()
 * 
 * TimerTask(任务抽象类)
 */
public class TimerDemo2 {
    public static void main(String[] args) {
        // 创建定时器对象
        Timer t = new Timer();
        
        // 3秒后执行爆炸任务
        // t.schedule(new MyTask(), 3000);
        
        // 3秒后执行爆炸任务第一次，如果不成功，每隔2秒再继续炸
        t.schedule(new MyTask2(), 3000, 2000);
    }
}

// 做一个任务
class MyTask2 extends TimerTask {
    
    @Override
    public void run() {
        System.out.println("beng，爆炸了");
    }

}

package cn.itcast_12;

import java.io.File;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/*
 * 需求：在指定的时间删除我们的指定目录(演示：使用项目路径下的demo)
 */
public class TimerTest {
    public static void main(String[] args) throws ParseException {
        Timer t = new Timer();

        String s = "2014-11-27 15:45:00";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(s);

        t.schedule(new DeleteFolder(), d);
    }
}


class DeleteFolder extends TimerTask {

    @Override
    public void run() {
        File srcFolder = new File("demo");
        deleteFolder(srcFolder);
    }

    // 递归删除目录
    public void deleteFolder(File srcFolder) {
        File[] fileArray = srcFolder.listFiles();
        if (fileArray != null) {
            for (File file : fileArray) {
                if (file.isDirectory()) {
                    deleteFolder(file);
                } else {
                    System.out.println(file.getName() + ":" + file.delete());
                }
            }
            System.out.println(srcFolder.getName() + ":" + srcFolder.delete());
        }
    }
    
}

--------------------------------------
    (11)多线程常见的面试题
        1:多线程有几种实现方案，分别是哪几种?
            两种。
            
            继承Thread类
            实现Runnable接口
            
            扩展一种：实现Callable接口。这个需要和线程池结合。
        --------------------------------------
        2:同步有几种方式，分别是什么?
            两种。
            
            同步代码块
            同步方法(静态同步方法)
        --------------------------------------
        3:启动一个线程是run()还是start()?它们的区别?
            start();
            
            run():封装了被线程执行的代码，直接调用仅仅是普通方法的调用。
            start():启动线程，并由JVM自动调用run()方法。
        --------------------------------------
        4:sleep()和wait()方法的区别?
            sleep():必须指定时间，不释放锁。
            wait():可以不指定时间，也可以指定时间，并立即释放锁。
        --------------------------------------
        5:为什么wait()、notify()、notifyAll()等方法都定义在Object类中?
            因为这些方法的调用是依赖于锁对象的，而同步代码块的锁对象是任意对象。
            而Object代码任意的对象，所以，它们定义在这里面。
        --------------------------------------
        6:线程的生命周期。
            新建-->就绪-->运行-->死亡
            新建-->就绪-->运行-->阻塞-->就绪-->运行-->死亡
            建议：画图解释。
-----------------------------------------------------------------------------
2:设计模式(理解)
    (1)面向对象思想的设计原则的概述
        在实际的开发中，我们要想更深入的了解面向对象思想，就必须熟悉前人总结过的面向对象思想的设计原则。
        
        单一职责原则
            核心思想：其实就是开发人员经常说的“高内聚”(自己能做的,不麻烦别人)。
            也就是说：每个类应该只有一个职责，对外只能提供一种功能，而引起类变化的原因应该只有一个。
            在设计模式中，所有的设计模式都遵循这一原则。

        开闭原则
            核心思想：一个对象对扩展开放，对修改关闭。
            其实开闭原则的意思就是：对类的改动是通过增加代码进行的，而不是修改现有代码。
            也就是说：软件开发人员一旦写出了可以运行的代码，就不应该去改动它，而是要保证它能一直运行下去，如何能够做到这一点呢?
            这就需要借助于抽象和多态，即把可能变化的内容抽象出来，从而使抽象的部分是相对稳定的，而具体的实现则是可以改变和扩展的。

        里氏替换原则
            核心思想：在任何父类出现的地方都可以用它的子类来替代。
            也就是说：同一个继承体系中的对象应该有共同的行为特征。
        
        依赖注入原则(Spring框架)
            核心思想：要依赖于抽象，不要依赖于具体实现。
            也就是说：在应用程序中，所有的类如果使用或依赖于其他的类，则应该依赖这些其他类的抽象类，而不是这些其他类的具体类。
            为了实现这一原则，就要求我们在编程的时候针对抽象类或者接口编程，而不是针对具体实现编程。
        
        接口分离原则
            核心思想：不应该强迫程序依赖它们不需要使用的方法。
            也就是说：一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口中。

        迪米特原则
            核心思想：一个对象应当对其他对象尽可能少的了解。即“低耦合”(不要牵一发而动全身)
            也就是说：降低各个对象之间的耦合，提高系统的可维护性。在模块之间应该只通过接口编程，而不理会模块的内部工作原理，它可以使各个模块耦合度降到最低，促进软件的复用。
        
        所有的原则都是为了提高程序的可维护性、可扩展性、可复用性。
--------------------------------------
    (2)设计模式
        A:设计模式的概述(设计模式是经验的总结）
            设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
            设计模式不是一种方法和技术，而是一种思想。
            设计模式和具体的语言无关，学习设计模式就是要建立面向对象的思想，尽可能的面向接口编程，低耦合，高内聚，使设计的程序可复用。
            学习设计模式能够促进对面向对象思想的理解，反之亦然，它们相辅相成。
        B:设计模式的几个要素
            名字：必须有一个简单、有意义的名字。
            问题：描述在何时使用模式。
            解决方案：描述设计的组成部分以及如何解决问题。
            效果：描述模式的效果以及优缺点。
        C:设计模式的分类
            创建型模式 对象的创建
            结构型模式 对象的组成(结构)
            行为型模式 对象的行为

            创建型模式：简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式。(6个)
            结构型模式：外观模式、适配器模式、代理模式、装饰模式、桥接模式、组合模式、享元模式。(7个)
            行为型模式：模版方法模式、观察者模式、状态模式、职责链模式、命令模式、访问者模式、策略模式、备忘录模式、迭代器模式、解释器模式。(10个)
--------------------------------------    
    (3)常见的设计模式
        A:简单工厂模式(单接口中用的多)
            简单工厂模式的概述
                又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例。
            优点
                创建对象的工作其实是比较麻烦的，有了简单工厂后，客户端不需要再负责对象的创建，从而明确了各个类的职责。
            缺点
                这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护。
            示例代码如下：

package cn.itcast_01;

public abstract class Animal {
    public abstract void eat();
}

package cn.itcast_01;

public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

}

package cn.itcast_01;

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

}

package cn.itcast_01;

public class AnimalFactory {

    private AnimalFactory() {
    }

    public static Animal createAnimal(String type) {
        if ("dog".equals(type)) {
            return new Dog();
        } else if ("cat".equals(type)) {
            return new Cat();
        } else {
            return null;
        }
    }
    
    /*
    public static Dog createDog() {
        return new Dog();
    }

    public static Cat createCat() {
        return new Cat();
    }
    */
}

package cn.itcast_01;

public class AnimalDemo {
    public static void main(String[] args) {
        // 具体类调用
        Dog d = new Dog();
        d.eat();
        Cat c = new Cat();
        c.eat();
        System.out.println("------------");

        // 动物工厂有了后，通过工厂造对象
        // Dog dd = AnimalFactory.createDog();
        // Cat cc = AnimalFactory.createCat();
        // dd.eat();
        // cc.eat();
        // System.out.println("------------");

        // 工厂改进后
        // 我要造只狗
        Animal a = AnimalFactory.createAnimal("dog");
        // 记住：用任何一个对象之前先判断该对象是否为空
        if (a != null) {
            a.eat();
        } else {
            System.out.println("对不起，暂时不提供这种动物");
        }
        
        // 我要造只猫
        a = AnimalFactory.createAnimal("cat");
        // 记住：用任何一个对象之前先判断该对象是否为空
        if (a != null) {
            a.eat();
        } else {
            System.out.println("对不起，暂时不提供这种动物");
        }

        // NullPointerException
        a = AnimalFactory.createAnimal("pig");
        // 记住：用任何一个对象之前先判断该对象是否为空
        if (a != null) {
            a.eat();
        } else {
            System.out.println("对不起，暂时不提供这种动物");
        }
    }
}

        B:工厂方法模式(多接口中用的多)
            工厂方法模式的概述
                工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
            优点
                客户端不需要再负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性。
            缺点
                需要额外的编写代码，增加了工作量。
            示例代码如下：

package cn.itcast_02;

public abstract class Animal {
    public abstract void eat();
}

package cn.itcast_02;

public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

}

package cn.itcast_02;

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

}

package cn.itcast_02;

public interface AnimalFactory {
    public abstract Animal createAnimal();
}

package cn.itcast_02;

public class DogFactory implements AnimalFactory {

    @Override
    public Animal createAnimal() {
        return new Dog();
    }

}

package cn.itcast_02;

public class CatFactory implements AnimalFactory {

    @Override
    public Animal createAnimal() {
        return new Cat();
    }

}

package cn.itcast_02;

public class AnimalDemo {
    public static void main(String[] args) {
        // 需求：我要造只狗
        AnimalFactory f = new DogFactory();
        Animal a = f.createAnimal();
        a.eat();
        System.out.println("------------");
        
        // 需求：我要造只猫
        f = new CatFactory();
        a = f.createAnimal();
        a.eat();
        
        // 需求：我要造只...
        // 只需要增加一个具体的类和具体的工厂类即可
    }
}

   
        C:单例设计模式(多线程中用的多)
            单例设计模式的概述
                单例模式就是要确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供。
            优点
                在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
            缺点
                没有抽象层，因此扩展很难。职责过重，在一定程序上违背了单一职责。
                
            a:饿汉式：类一加载就创建对象了。
            b:懒汉式：用的时候，才去创建对象。
            
            开发中：饿汉式(是不会出现问题的单例模式)
            面试中：懒汉式(可能会出现问题的单例模式)

　　　　　　　　出现什么问题呢？
　　　　　　　　　　A:懒加载思想(延迟加载思想)
　　　　　　　　　　B:出现线程安全问题
　　　　　　　　　　　　a:是否是多线程环境 　　　　　　 是
　　　　　　　　　　　　b:是否有共享数据 　　 　　　　  是
　　　　　　　　　　　　c:是否有多条语句操作共享数据 　 是

　　　　　　示例代码如下：
饿汉式示例代码：

package cn.itcast_03;

public class Student {
    
    // 构造私有，外界就不能造对象了
    private Student() {
    }
    
    // 在成员变量位置自己创建一个对象
    // 静态方法只能访问静态成员变量，所以成员变量加静态修饰
    // 为了不让外界直接访问修改这个成员变量的值，所以该成员变量加private修饰
    private static Student s = new Student();

    // 提供公共的访问方式，返回该对象。为了保证外界能够直接访问该方法，所以方法加静态修饰
    public static Student getStudent() {
        return s;
    }
}

package cn.itcast_03;

/*
 * 单例模式：就是要确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供。
 * 
 * 如何保证该类在内存中只有一个对象呢?
 *         A：把构造方法私有，外界就不能造对象了。
 * 
 * 如何保证该类的对象的自动创建，并且对外提供呢?
 *         A：在成员变量位置自己创建一个对象。静态方法只能访问静态成员变量，所以成员变量加静态修饰。
 *             为了不让外界直接访问修改这个成员变量的值，所以该成员变量加private修饰。
 *         B：通过一个公共的方法提供访问，返回该对象。为了保证外界能够直接访问该方法，所以方法加静态修饰。
 */
public class StudentDemo {
    public static void main(String[] args) {
        // Student s1 = new Student();
        // Student s2 = new Student();
        // System.out.println(s1 == s2); // false

        // 通过单例如何得到对象呢?先注意一个问题：外界能直接访问修改这个成员变量的值
        // Student.s = null;
        //
        // Student s1 = Student.getStudent();
        // Student s2 = Student.getStudent();
        // System.out.println(s1 == s2); // true
        //
        // System.out.println(s1); // null
        // System.out.println(s2); // null
        
        // 为了不让外界直接访问修改这个成员变量的值，所以该成员变量加private修饰。
        // 通过单例如何得到对象呢?
        Student s1 = Student.getStudent();
        Student s2 = Student.getStudent();
        System.out.println(s1 == s2);  // true

        System.out.println(s1); // cn.itcast_03.Student@3c679bde
        System.out.println(s2); // cn.itcast_03.Student@3c679bde
        
    }
}

懒汉式示例代码：

package cn.itcast_03;

/*
 * 单例模式：
 *         饿汉式：类一加载就创建对象了。
 *         懒汉式：用的时候，才去创建对象。
 * 
 * 面试题：
 *         单例模式的思想是什么? 答：确保类在内存中只有一个对象。
 *         请写一个代码体现。
 * 
 *         开发中：饿汉式(是不会出现问题的单例模式)
 *         面试中：懒汉式(可能会出现问题的单例模式)
 * 
 *         出现什么问题呢？
 *             A:懒加载思想(延迟加载思想)    
 *             B:出现线程安全问题
 *                 a:是否是多线程环境            是
 *                 b:是否有共享数据            是
 *                 c:是否有多条语句操作共享数据     是
 */
public class Teacher {
    private Teacher() {
    }

    private static Teacher t = null;

    public static synchronized Teacher getTeacher() {
        if (t == null) {
            t = new Teacher();
        }
        return t;
    }
    
}

package cn.itcast_03;

public class TeacherDemo {
    public static void main(String[] args) {
        Teacher t1 = Teacher.getTeacher();
        Teacher t2 = Teacher.getTeacher();
        System.out.println(t1 == t2); // true
        System.out.println(t1); // cn.itcast_03.Teacher@3c679bde
        System.out.println(t2); // cn.itcast_03.Teacher@3c679bde
    }
}

--------------------------------------
    (4)Runtime类的概述和应用
        A:Runtime类的概述
            每个Java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接。可以通过getRuntime()方法获取当前运行时对象。 
            应用程序不能创建自己的Runtime类实例。 
        B:Runtime类使用
            public Process exec(String command) 在单独的进程中执行指定的字符串命令(该方法会抛出异常)
        
        JDK提供的一个单例模式应用的类Runtime类。
        该类的对象可以调用dos命令。
　　　　 示例代码如下：

package cn.itcast_04;

import java.io.IOException;

/*
 * Runtime类:每 Java应用程序都有一个 Runtime类实例，使应用程序能够与其运行的环境相连接。可以通过getRuntime()方法获取当前运行时对象。
 *         public Process exec(String command) 在单独的进程中执行指定的字符串命令
 *             该类的对象可以调用dos命令。
 * 
 * JDK提供的一个单例模式应用的类Runtime类。
 */
public class RuntimeDemo {
    public static void main(String[] args) throws IOException {
        Runtime r = Runtime.getRuntime();
        // r.exec("winmine"); // 打开扫雷游戏
        // r.exec("notepad");
        r.exec("calc");
        // r.exec("shutdown -s -t 10000"); // 定时10000s秒后关机
        // r.exec("shutdown -a"); // 取消关机命令
    }
}

/*
 * Runtime类的源码小解析：
 *
 * class Runtime {
 *         private Runtime() {}
 *         private static Runtime currentRuntime = new Runtime(); // 单例设计模式之饿汉式
 *         public static Runtime getRuntime() {
 *           return currentRuntime;
 *       }
 * }
 */

        Runtime类的源码小解析：
        class Runtime {
            private Runtime() {}
            private static Runtime currentRuntime = new Runtime(); // 单例设计模式之饿汉式
            public static Runtime getRuntime() {
                return currentRuntime;
            }
        }
=============================================================================