并发---使用ScheduledExecutor的温室控制器

ScheduledExecutor

• ScheduledThreadPoolExecutor。通过使用schedule（）（运行一次任务）或者scheduleAtFixedRate（）（每隔规则的时间重复执行任务）。可以将Runnable对象设置为在将来的某个时刻执行。

package com21concurrent;


import java.util.*;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created by Panda on 2018/6/1.
 */
public class GreenhouseScheduler {
    private volatile boolean light=false;
    private volatile boolean water=false;
    private String thermostat="Day";
    private synchronized String getThermostat(){
        return thermostat;
    }
    public synchronized void setThermostat(String thermostat){
        this.thermostat=thermostat;
    }
    ScheduledThreadPoolExecutor executor= new ScheduledThreadPoolExecutor(10);
    public void schedule(Runnable runnable,long delay){
        //创建并执行在给定延迟后启用的executor
         executor.schedule(runnable,delay, TimeUnit.MILLISECONDS);
    }
    public void repeat(Runnable runnable,long initialDelay,long period){
        executor.scheduleAtFixedRate(runnable,initialDelay,period,TimeUnit.MILLISECONDS);
    }

    class LightOn implements Runnable{
        @Override
        public void run() {
            System.out.println("Turing on lights");
            light=true;
        }
    }

    class LightOff implements Runnable{
        @Override
        public void run() {
            System.out.println("Turning off lights");
            light=false;
        }
    }

    class WaterOn implements Runnable{
        @Override
        public void run() {
            System.out.println("Turing greenhouse water on");
            water=true;
        }
    }

    class WaterOff implements Runnable{
        @Override
        public void run() {
            System.out.println("Turing greenhouse water off");
            water=false;
        }
    }

    class ThermostatDay implements Runnable{
        @Override
        public void run() {
            System.out.println("ThermostatDay to Day setting");
            setThermostat("Day");
        }
    }

    class ThermostatNight implements Runnable{
        @Override
        public void run() {
            System.out.println("ThermostatNight to Night setting");
            setThermostat("Night");
        }
    }

    class Bell implements Runnable{
        @Override
        public void run() {
            System.out.println("Bing!");
        }
    }

    class Terminate implements Runnable{
        @Override
        public void run() {
            System.out.println("Terminating");
            executor.shutdownNow();

            new Thread(){
                public void run(){
                  for(DataPoint dataPoint:data)
                      System.out.println(dataPoint);
                }
            }.start();
        }
    }

    static class DataPoint{
        final Calendar time;
        final float temperature;
        final float humidity;

        public DataPoint(Calendar time, float temperature, float humidity) {
            this.time = time;
            this.temperature = temperature;
            this.humidity = humidity;
        }
        public String toString(){
            return time.getTime()+String.format(" temperature: %1$.1f humidity:%2$.2f",temperature,humidity);
        }
    }
    private Calendar lastTime = Calendar.getInstance();
    {
        lastTime.set(Calendar.MINUTE,30);
        lastTime.set(Calendar.SECOND,00);
    }

    private float lastTemp=65.0f;
    private int tempDirection=+1;
    private float lastHumidity=50.0f;
    private int humidityDirection=+1;
    private Random random = new Random(47);
    List<DataPoint> data= Collections.synchronizedList(new ArrayList<DataPoint>());
    class CollectData implements Runnable{
        @Override
        public void run() {
            System.out.println("Collecting data");
            synchronized (GreenhouseScheduler.this){
                lastTime.set(Calendar.MINUTE,lastTime.get(Calendar.MINUTE)+30);
                if(random.nextInt(5)==4) tempDirection=-1;
                lastTemp=lastTemp+tempDirection*(1.0f+random.nextFloat());

                if(random.nextInt(5)==4) humidityDirection=-1;
                lastHumidity=lastHumidity+humidityDirection*random.nextFloat();

                data.add(new DataPoint((Calendar)lastTime.clone(),lastTemp,lastHumidity));
            }
        }
    }

    public static void main(String[] args) {
        GreenhouseScheduler greenhouseScheduler = new GreenhouseScheduler();
        greenhouseScheduler.schedule(greenhouseScheduler.new Terminate(),5000);
        greenhouseScheduler.repeat(greenhouseScheduler.new Bell(),0,1000);
        greenhouseScheduler.repeat(greenhouseScheduler.new ThermostatNight(),0,2000);
        greenhouseScheduler.repeat(greenhouseScheduler.new LightOn(),0,200);
        greenhouseScheduler.repeat(greenhouseScheduler.new LightOff(),0,400);
        greenhouseScheduler.repeat(greenhouseScheduler.new WaterOn(),0,600);
        greenhouseScheduler.repeat(greenhouseScheduler.new WaterOff(),0,800);
        greenhouseScheduler.repeat(greenhouseScheduler.new ThermostatDay(),0,1400);
        greenhouseScheduler.repeat(greenhouseScheduler.new CollectData(),500,500);
    }
}