Java学习笔记-----Twenty-three（线程池，定时器，设计模式）

1.线程的状态转换及常见执行情况
线程的状态： 新建 , 就绪 , 运行 , 冻结 , 死亡
新建:线程被创建出来
就绪:具有CPU的执行资格,但是不具有CPU的执行权
运行:具有CPU的执行资格,也具有CPU的执行权
阻塞:不具有CPU的执行资格,也不具有CPU的执行权
死亡:不具有CPU的执行资格,也不具有CPU的执行权
2. 线程池
public static ExecutorService newCachedThreadPool(): 根据任务的数量来创建线程对应的线程个数
public static ExecutorService newFixedThreadPool(int nThreads): 固定初始化几个线程
public static ExecutorService newSingleThreadExecutor(): 初始化一个线程的线程池
这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
Future<?> submit(Runnable task)
Future submit(Callable task)
3. 匿名内部类的方式实现多线程程序
new Thread(){代码…}.start();
new Thread(new Runnable(){代码…}).start();
4.定时器
Timer和TimerTask
Timer:
public Timer()
public void schedule(TimerTask task, long delay):
public void schedule(TimerTask task,long delay,long period);
public void schedule(TimerTask task, Date time):
public void schedule(TimerTask task, Date firstTime, long period):
TimerTask
public abstract void run()
public boolean cancel()
开发中Quartz是一个完全由java编写的开源调度框架。
5.设计模式
A:设计模式概述
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性以及代码的结构更加清晰.
B:设计模式分类
创建型模式(创建对象的): 单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。
行为型模式(对象的功能): 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
结构型模式(对象的组成): 模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解 释器模式、状态模式、策略模式、职责链模式、访问者模式。
6. 简单工厂模式
A:简单工厂模式概述: 又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例
B:优点: 使用静态工厂模式的优点是实现责任的分割，该模式的核心是工厂类，工厂类含有必要的选择逻辑，可以决定什么时候创建哪一个产品的实例，而客户端则免去直接创建产品的责任，而仅仅是消费产品。也就是说静态工厂模式在不改变客户端代码的情况可以动态的增加产品。明确了类的职责
C:缺点
这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，
就需要不断的修改工厂类，不利于后期的维护
案例演示： 请编写简单工厂模式，并测试

public class Test2 {
    public static void main(String[] args) {
        //简单工厂模式
        Tree appleTree = TreeFactory.getTree("appleTree");
        appleTree.food();

        Tree orangeTree = TreeFactory.getTree("orangeTree");
        orangeTree.food();

        Tree cherryTree = TreeFactory.getTree("cherryTree");
        cherryTree.food();
    }
}


class TreeFactory{
    public static Tree getTree(String name){
        if ("appleTree".equals(name)){
            return new AppleTree();
        }else if ("orangeTree".equals(name)){
            return new OrangeTree();
        }else if ("cherryTree".equals(name)){
            return new CherryTree();
        }else {
    return null;}
    }
}

abstract class Tree{
    public abstract void food();
}

class AppleTree extends Tree{
    @Override
    public void food() {
        System.out.println("苹果！");
    }
}

class OrangeTree extends Tree{
    @Override
    public void food() {
        System.out.println("橘子！");
    }
}

class  CherryTree extends Tree{
    @Override
    public void food() {
        System.out.println("樱桃！");
    }
}

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

public class Test3 {
    public static void main(String[] args) {
        //工厂方法模式
        Teacher ch = new ChineseTeacherFactory().createTeacher();
        ch.teach();
        Teacher ma = new MathTeacherFactory().createTeacher();
        ma.teach();
        Teacher en = new EnglishTeacherFactory().createTeacher();
        en.teach();
    }
}


interface BigFactory{
    Teacher createTeacher();
}


 abstract class Teacher{
    public abstract void teach();
 }


 class ChineseTeacher extends Teacher{
     @Override
     public void teach() {
         System.out.println("语文老师教国语！");
     }
 }


class ChineseTeacherFactory implements BigFactory {
    @Override
    public Teacher createTeacher() {
        return new ChineseTeacher();
    }
}

class MathTeacher extends Teacher{
    @Override
    public void teach() {
        System.out.println("数学老师教高数！");
    }
}


class MathTeacherFactory implements BigFactory{
    @Override
    public Teacher createTeacher() {
        return new MathTeacher();
    }
}


class EnglishTeacher extends Teacher{
    @Override
    public void teach() {
        System.out.println("英语老师教英语！");
    }
}


class EnglishTeacherFactory implements BigFactory{
    @Override
    public Teacher createTeacher() {
        return new EnglishTeacher();
    }
}

8.单例模式
单例设计模式之懒汉式

	开发中		饿汉式
	面试中		懒汉式

案例演示：编写单例模式，并测试

public class Test {
    public static void main(String[] args) {
        //饿汉式
        Phone phone = Phone.getPhone();
        Phone phone1 = Phone.getPhone();
        System.out.println(phone==phone1);
    }
}

class Phone{
    private  static Phone phone=new Phone();

    public Phone() {
    }
    public static Phone getPhone(){
        return phone;
    }
}

//懒汉式(线程安全版本)
public class Test1 {
    public static void main(String[] args) {
        Cat cat = Cat.getCat();
        Cat cat1 = Cat.getCat();
        System.out.println(cat==cat1);
    }
}


class Cat{
    private static Cat cat=null;
    public Cat() {
    }
    public synchronized static Cat getCat(){
        if (cat==null){
            cat=new Cat();
            return cat;
        }
    return cat;
    }
}