懒汉模式&饿汉模式+线程池实例

单例设计模式：保证类在内存中只有一个对象
//饿汉式
class Singleton {
    //1,私有构造方法,其他类不能访问该构造方法了
    private Singleton(){}
    //2,声明一个引用
    private static Singleton s = new Singleton();
    //3,对外提供公共的访问方法
    public static Singleton getInstance() {                //获取实例
        return s;
    }
}




//懒汉式
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;
    }
}




Singleton s1 = Singleton.s;                //成员变量被私有,不能通过类名.调用
Singleton s1 = Singleton.getInstance();





饿汉式和懒汉式的区别
 * 1,饿汉式是空间换时间,懒汉式是时间换空间
 * 2,在多线程访问时,饿汉式不会创建多个对象,而懒汉式有可能会创建多个对象





单例设计模式的应用
Runtime r = Runtime.getRuntime();        //获取运行时对象
r.exec("shutdown -s -t 300");            //设置电脑300秒后关机    
r.exec("shutdown -a");                //取消关机计划




Timer t = new Timer();                //计时器
//第一个参数,是安排的任务,第二个参数是执行的时间,第三个参数是过多长时间再重复执行
t.schedule(new MyTimerTask(), new Date(118, 9, 4, 15, 57, 50),3000);
class MyTimerTask extends TimerTask {
    public void run() {
        System.out.println("起床背英语单词");
    }
}





synchronized(this){
    this.wait();                //当前线程等待
    this.notify();                //随机唤醒单个等待的线程
    this.notifyAll();            //唤醒所有等待的线程
}





ReentrantLock r = new ReentrantLock();
Condition c1 = r.newCondition();
Condition c2 = r.newCondition();
Condition c3 = r.newCondition();
r.lock();                    //获取锁
r.unlock();                    //释放锁
c1.await();                    //c1线程等待
c2.await();                    //c2线程等待
c3.await();                    //c3线程等待
c1.signal();                    //即将执行c1线程
c2.signal();                    //即将执行c2线程
c3.signal();                    //即将执行c3线程





ThreadGroup tg = new ThreadGroup("我是一个新的线程组");        //创建新的线程组
MyRunnable mr = new MyRunnable();                //创建Runnable的子类对象    
Thread t1 = new Thread(tg, mr, "张三");                //将线程t1放在组中
Thread t2 = new Thread(tg, mr, "李四");                //将线程t2放在组中
t1.getThreadGroup().getName()；                    //获取组名
class MyRunnable implements Runnable {
    public void run() {}
}




ExecutorService pool = Executors.newFixedThreadPool(2);    //创建线程池
pool.submit(new MyRunnable());                //将线程放进池子里并执行
pool.submit(new MyRunnable());        
pool.shutdown();                    //关闭线程池




ExecutorService pool = Executors.newFixedThreadPool(1);    //创建线程池
Future<Integer> f1 = pool.submit(new MyCallable(100));    //将线程放进池子里并执行
f1.get();                        //获取call()计算结果
class MyCallable implements Callable<Integer> {
    private int num;
    public MyCallable(int num) {            //构造方法
        this.num = num;
    }    
    public Integer call() throws Exception {    //重写call()方法
        int sum = 0;
        for(int i = 1; i <= num; i++) {        //计算1-num的和
            sum += i;
        }        
        return sum;
    }
}