一、线程池

1、线程池概述

	程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。
	而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。
	线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。

2、线程池的使用

JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
	public static ExecutorService newCachedThreadPool()://根据任务的数量来创建线程池对应的线程个数	
	public static ExecutorService newFixedThreadPool(int nThreads)://固定初始化几个线程
	public static ExecutorService newSingleThreadExecutor()://初始化一个线程的线程池
	这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。
	它提供了如下方法:
		Future<?> submit(Runnable task)
		<T> Future<T> submit(Callable<T> task)

示例一

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

public class MyTest {
    public static void main(String[] args) {
        //获取线程池对象,固定初始化3个线程
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        //给线程池添加任务
        executorService.submit(new MyRunnable());
        executorService.submit(new MyRunnable());
        executorService.submit(new MyRunnable());
        executorService.submit(new MyRunnable());
        executorService.submit(new MyRunnable());
        executorService.submit(new MyRunnable());
        executorService.shutdown();//关闭线程池
    }
}
class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":任务执行了！");
    }
}

运行结果：

pool-1-thread-1:任务执行了！
pool-1-thread-3:任务执行了！
pool-1-thread-1:任务执行了！
pool-1-thread-3:任务执行了！
pool-1-thread-1:任务执行了！
pool-1-thread-2:任务执行了！

Process finished with exit code 0

示例二

import java.util.concurrent.*;

public class MyTest1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //获取初始化一个线程的线程池对象
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        //添加任务
        Future<Integer> submit = executorService.submit(new MyCallable(100));
        Integer sum = submit.get();//获取call方法返回值
        System.out.println(sum);//5050
        Future<Integer> submit1 = executorService.submit(new MyCallable(200));
        Integer sum1 = submit1.get();
        System.out.println(sum1);//20100
        executorService.shutdown();//关闭线程池
    }
}
class MyCallable implements Callable<Integer>{
    int num;
    public MyCallable(int num) {
        this.num=num;
    }

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

二、定时器

1、定时器概述

	定时器是一个应用十分广泛的线程工具，可用于调度多个定时任务以后台线程的方式执行。在Java
中，可以通过Timer和TimerTask类来实现定义调度的功能。

2、定时器的使用

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()//取消此计时器任务

示例：控制台实时打印当前时间，精确到秒

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class MyTest {
    public static void main(String[] args) {
        Timer timer = new Timer();//获取定时器
        MyTimerTask myTimerTask = new MyTimerTask(timer);
        timer.schedule(myTimerTask, 0, 1000);//每隔一秒，执行一次计时器任务
    }
}

class MyTimerTask extends TimerTask {
    Timer timer;

    public MyTimerTask(Timer timer) {
        this.timer = timer;
    }

    @Override
    public void run() {
        String format = new SimpleDateFormat("yyyy-MM-dd E HH:mm:ss").format(new Date());
        System.out.println(format);
    }
}

运行结果：

2019-08-01 星期四 15:45:13
2019-08-01 星期四 15:45:14
2019-08-01 星期四 15:45:15
2019-08-01 星期四 15:45:16
2019-08-01 星期四 15:45:17
    ............

三、设计模式

1、概述及分类

A:设计模式概述
	设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编写的代码设计经验的总结。
	使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性以及代码的结构更加清晰.
B:设计模式分类
	创建型模式(创建对象的):单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。
	行为型模式(对象的功能):适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
	结构型模式(对象的组成):模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、
备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

2、工厂模式

2.1、简单工厂模式

	概述:又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例。
	优点:使用静态工厂模式的优点是实现责任的分割，该模式的核心是工厂类，工厂类含有必要的选择逻
辑，可以决定什么时候创建哪一个产品的实例，而客户端则免去直接创建产品的责任，而仅仅是消费产
品。也就是说静态工厂模式在不改变客户端代码的情况可以动态的增加产品。
	缺点:这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就
需要不断的修改工厂类，不利于后期的维护

public class MyTest {
    public static void main(String[] args) {
        //通过工厂类的静态方法获取动物对象
        Animal dog = AnimalFactory.getAnimal("dog");
        Animal cat = AnimalFactory.getAnimal("cat");
        dog.eat();//狗吃肉
        cat.eat();//猫吃鱼
    }
}
class AnimalFactory{

    private AnimalFactory() {}
    public static Animal getAnimal(String animalName){
        if(animalName.equals("dog")){
            return new Dog();
        }else if(animalName.equals("cat")){
            return new Cat();
        }
        return null;
    }

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

class Dog extends Animal{

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

class Cat extends Animal{

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

2.2、工厂方法模式

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

public class MyTest {
    public static void main(String[] args) {
        //获取动物对象
        Animal cat = new CatFactory().createAnimal();
        Animal dog = new DogFactory().createAnimal();
        //调用方法
        cat.eat();
        dog.eat();
    }
}
interface Factory{
    Animal createAnimal();
}

class CatFactory implements Factory{

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

class DogFactory implements Factory{

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

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

class Dog extends Animal{

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

class Cat extends Animal{

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

3、单例模式

public class MyTest {
    public static void main(String[] args) {
        Student student = Student.getStudent();
        Student student1 = Student.getStudent();
        System.out.println(student==student1);//true

        Teacher teacher = Teacher.getTeacher();
        Teacher teacher1 = Teacher.getTeacher();
        System.out.println(teacher==teacher1);//true
    }
}

//一、饿汉式
class Student{
    private static Student stu=new Student();
    private Student(){} //私有构造方法
    public static Student getStudent(){
        return stu;
    }
}

//二、懒汉式
class Teacher{
    private static Teacher teacher;
    private Teacher() {}
    public synchronized static Teacher getTeacher(){
        if(teacher==null){
            teacher=new Teacher();
        }
        return teacher;
    }
}

四、Java程序执行DOS命令

Runtime类：
	每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。 
	应用程序不能创建自己的 Runtime 类实例。 
	public Process  exec(String command)  //执行Dos 命令

示例：使用DOS命令定时关机

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Timer;
import java.util.TimerTask;

public class MyTest {
    public static void main(String[] args) throws  ParseException {
        //Runtime 采用单例模式的饿汉式
        Runtime runtime = Runtime.getRuntime();
        //定时关机
        Timer timer = new Timer();
        //在指定日期执行计时器任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                try {
                    runtime.exec("shutdown -s -t 0");//DOS命令(0毫秒后关机)
                } catch (IOException e) {

                    e.printStackTrace();
                }
            }
        },new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2019-08-01 16:59:00"));
    }
}