0827总结

0827总结

线程的生命周期

NEW：至今尚未启动的线程处于这种状态
RUNNABLE：正在 Java 虚拟机中执行的线程处于这种状态
BLOCKED：受阻塞并等待某个监视器锁的线程处于这种状态
WAITING：无限期地等待另一个线程来执行某一特定操作的线程处于这种状态
TIMED_WAITING：等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态
TERMINATED：已退出的线程处于这种状态
【获取线程的状态的方法：Thread.State getState()】

生产者与消费者模式

该模式为了避免资源的浪费（生产一个就消费一个）
wait() 可以加参数，也可以不加参数
notify() 唤醒 当前睡眠的对象
notifyAll() 表示唤醒所有对象

public class Test4 {
    //产品
    static class Product {
        private static volatile String values;
    }

    //生产者
    static class Producter extends Thread {
        //产品的对象
        private Object obj;

        public Producter(Object obj) {
            this.obj = obj;
        }

        @Override
        public void run() {
            while (true) {
                synchronized (obj) {
                    //产品不等于空就等待
                    if (Product.values != null) {
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    //产品等于空就生产，先赋值（等于生产）
                    Product.values=""+System.currentTimeMillis();
                    System.out.println("现在马上生产"+Product.values);
                    //通知消费者
                    obj.notify();
                }
            }
        }
    }
    //消费者
    static class Custmer extends Thread{
        //产品的对象
         private Object obj;

        public Custmer(Object obj) {
            this.obj = obj;
        }

        @Override
        public void run() {
            while (true){
                synchronized (obj){
                    //产品为空时就等待
                    if (Product.values==null){
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    //产品不等于空就开始消费
                    System.out.println("正在消费"+Product.values);
                    Product.values=null;
                    obj.notify();
                }
            }
        }
    }

    public static void main(String[] args) {
        //实例化生产者对象
        Object obj=new Object();
        new Producter(obj).start();
        new Custmer(obj).start();
    }
}

Timer （定时操作类）

Timer time=new Timer();
time.schedule(TimerTask task, long delay, long period);  //注意捕获异常

第一个参数传递了一个任务对象,第二个参数是隔多少秒来执行这个操作,第三个参数是每次间隔发送的时间，时间是以毫秒值为单位（也可以传递Date 参数）

线程池

创建一个单线程的线程池：Executors.newSingleThreadExecutor()
创建有多个线程的线程池：Executors.newFixedThreadPool(num:)
将一个任务类对象提交到线程池中:
【两者的区别：Runable无返回值；Callable有返回值】
1、submit(Runnable r)
2、submit(Callable a)
使用方法

ExecutorService es=Executors.newFixedThreadPool(3);
        Future f=es.submit(new MyCallable(100));

单例设置模式

有且仅加载一个类，静态的也可以有且仅加载一次(问题比较多)
工具类大部分都是单例设计模式
步骤：
1、私有的属性：这个属性是当前类（ 外部不能来访问这个属性）
2、私有的构造：不让外部来实例化这个类，使用私有的构造
3、公有的方法：提供一个对外的方法，让别人进行访问

1、饿汉模式

一开始就实例化出来，
缺点很多：运行就卡；优点：线程安全

private DateFormatUtils utils = new DateFormatUtils()
private DateFormatUtils(){
}       
public DateFormatUtils getInstance(){
    return utils
}

2、懒汉模式

不到使用的时候都不加载；性能有所优化，但是线程不安全

3、老汉模式

不能被修改，加了final关键字

private final DateFormatUtils utils  = new DateFormatUtils()

4、双重锁

利用同步方法来让一个线程进入里面在加一个同步代码块

private synchronize static FileUtils getInstance(){
    
}

简单工厂模式

1、定义一个方法通过参数来确定需要实例化哪一个对象
2、定义一个接口返回的对象是父类,子类通过继承这个接口,来重写方法,返回new出来的子类对象

枚举

枚举类里都是常量,所以定义的时候都是大写,也可以是汉字，但是不建议使用；常量之间用逗号进行分隔
枚举类似于接口，关键字是：Enum
开发里枚举对象跟Switch搭配最多
可以重写枚举对象的构造方法,但枚举的构造方法只能够自己使用,定义枚举常量的写法:名字1(构造方法参数),名字2(构造方法参数)