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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
单例设计模式：保证类在内存中只有一个对象
//饿汉式
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;
    }
}