public class EffectTest extends Application {

 StackPane root;

 private static int MAX_DATA_POINTS = ;

 private static int Y_DATA_RANGE = ;

 private static int TICK_UNIT = ;

 private static int UPDATE_INTERVAL_MS = ;

 private LineChart.Series<Number, Number> series1;

 private LineChart<Number, Number> lineChart;

 private NumberAxis xAxis = new NumberAxis();

 private NumberAxis yAxis = new NumberAxis();

 private SequentialTransition animation;

 private Paint paintXticklabel;

 private double nextX = ;

 Random rnd = new Random();

 double currentMemBAK=;

 public EffectTest() {

 Timeline timeline = new Timeline();

 timeline.getKeyFrames().add(new KeyFrame(Duration.millis(UPDATE_INTERVAL_MS*), new EventHandler<ActionEvent>() {

 @Override

 public void handle(ActionEvent actionEvent) {

 // update chart data

 // note that we add one data point and remove one data point in this simple example.

 // in a production environment you'd have to add multiple and remove multiple data points

 double currentMem= Runtime.getRuntime().totalMemory()-Runtime.getRuntime().freeMemory();

 double drawy =(currentMem-currentMemBAK)/;

 currentMemBAK=currentMem;

 System.out.println("currentMem:"+currentMem);

 // add new points

 //series1.getData().add(new XYChart.Data<Number, Number>(nextX, Math.cos(Math.toRadians(nextX)) * Y_DATA_RANGE));

 //mem

 series1.getData().add(new XYChart.Data<Number, Number>(nextX, drawy+));

 //cpu

 //series1.getData().add(new XYChart.Data<Number, Number>(nextX, getCpuRatioForWindows()));

 // remove points that shouldn't be visible anymore

 if (series1.getData().size() > MAX_DATA_POINTS) {

 series1.getData().remove();

 }

 System.out.println("node size:"+series1.getData().size());

 nextX += ;

 // update using series 1 as reference

 // series 2 contains same amount of data; if it doesn't for your case,

 // you need to adapt this here and calculate the proper range

 List<Data<Number, Number>> data = series1.getData();

 xAxis.setLowerBound(data.get().getXValue().doubleValue());

 xAxis.setUpperBound(data.get(data.size() - ).getXValue().doubleValue());

 ////////

 lineChart.getXAxis().setTickLabelFill(paintXticklabel);

 // xAxis.setTickUnit(1);

 root.setTranslateX(-);

 }

 }));

 timeline.setCycleCount(Animation.INDEFINITE);

 animation = new SequentialTransition();

 animation.getChildren().addAll(timeline);

 }

 public Parent createContent() {

 xAxis = new NumberAxis();

 xAxis.setForceZeroInRange(false);

 xAxis.setAutoRanging(false);

 xAxis.setTickLabelsVisible(false);

 xAxis.setTickMarkVisible(false);

 xAxis.setMinorTickVisible(false);

 xAxis=new NumberAxis(, Y_DATA_RANGE+, TICK_UNIT/);

 // set Axis property

 // final NumberAxis yAxis = new NumberAxis(1, 21, 0.1);

 // xAxis.setTickUnit(1);

 // xAxis.setPrefWidth(35);

 // xAxis.setMinorTickCount(10);

 // xAxis.setSide(Side.RIGHT);

 // xAxis.setTickLabelFormatter(new NumberAxis.DefaultFormatter(xAxis) {

 // @Override

 // public String toString(Number object) {

 // String label;

 // label = String.format("%7.2f", object.floatValue());

 // return label;

 // }

 // }); 

 //yAxis = new NumberAxis(-Y_DATA_RANGE, Y_DATA_RANGE, TICK_UNIT);

 yAxis = new NumberAxis(, Y_DATA_RANGE+, TICK_UNIT/);

 yAxis.setAutoRanging(false);

 lineChart = new LineChart<>(xAxis, yAxis);

 lineChart.setAnimated(false);

 lineChart.setLegendVisible(false); 

 //set if dont want symbols on the point

 lineChart.setCreateSymbols(false);

 series1 = new LineChart.Series<>();

 // series1.getData().add(new LineChart.Data<Number, Number>(0d, 0d));

 lineChart.getData().add(series1);

 //save ticklabe

 paintXticklabel=xAxis.getTickLabelFill();

 return lineChart;

 }

 public void play() {

 animation.play();

 }

 @Override

 public void stop() {

 animation.pause();

 }

 @Override

 public void start(Stage primaryStage) throws Exception {

 primaryStage.setTitle("Drawing Operations Test");

 root = new StackPane();

 root.getChildren().add(createContent()); 

 Scene s= new Scene(root);

 primaryStage.setScene(s);

 primaryStage.show(); 

 play();

 }

 public static void main(String[] args) {

 launch(args);

 // getCpuRatioForWindows() ;

 System.out.println(getCpuRatioForWindows());

 }

 private static final int CPUTIME = ;

 private static final int PERCENT = ; 

 public static double getCpuRatioForWindows()

 {

 try

 {

 String procCmd =

 System.getenv("windir")

 + "\\system32\\wbem\\wmic.exe process get Caption,CommandLine,KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount"; 

 long[] c0 = readCpu(Runtime.getRuntime().exec(procCmd));

 Thread.sleep(CPUTIME);

 long[] c1 = readCpu(Runtime.getRuntime().exec(procCmd));

 if (c0 != null && c1 != null)

 {

 long idletime = c1[] - c0[];

 long busytime = c1[] - c0[];

 return Double.valueOf(PERCENT * (busytime) * 1.0 / (busytime + idletime)).intValue() ;

 }

 else

 {

 return  ;

 }

 }

 catch (Exception ex)

 {

 ex.printStackTrace();

 return  ;

 }

 }

 private static final int FAULTLENGTH = ;

 private static long[] readCpu(final Process proc)

 {

 long[] retn = new long[];

 try

 {

 proc.getOutputStream().close();

 InputStreamReader ir = new InputStreamReader(proc.getInputStream());

 LineNumberReader input = new LineNumberReader(ir);

 String line = input.readLine();

 if (line == null || line.length() < FAULTLENGTH)

 {

 return null;

 }

 int capidx = line.indexOf("Caption");

 int cmdidx = line.indexOf("CommandLine");

 int rocidx = line.indexOf("ReadOperationCount");

 int umtidx = line.indexOf("UserModeTime");

 int kmtidx = line.indexOf("KernelModeTime");

 int wocidx = line.indexOf("WriteOperationCount");

 long idletime = ;

 long kneltime = ;

 long usertime = ;

 while ((line = input.readLine()) != null)

 {

 if (line.length() < wocidx)

 {

 continue;

 }

 //Caption,CommandLine,KernelModeTime,ReadOperationCount,

 // ThreadCount,UserModeTime,WriteOperation

 String caption = substring(line, capidx, cmdidx - ).trim();

 String cmd = substring(line, cmdidx, kmtidx - ).trim();

 if (cmd.indexOf("wmic.exe") >= )

 {

 continue;

 }

 String s1 = substring(line, kmtidx, rocidx - ).trim();

 String s2 = substring(line, umtidx, wocidx - ).trim();

 if (caption.equals("System Idle Process") || caption.equals("System"))

 {

 if (s1.length() > )

 idletime += Long.valueOf(s1).longValue();

 if (s2.length() > )

 idletime += Long.valueOf(s2).longValue();

 continue;

 }

 if (s1.length() > )

 kneltime += Long.valueOf(s1).longValue();

 if (s2.length() > )

 usertime += Long.valueOf(s2).longValue();

 }

 retn[] = idletime;

 retn[] = kneltime + usertime;

 return retn;

 }

 catch (Exception ex)

 {

 ex.printStackTrace();

 }

 finally

 {

 try

 {

 proc.getInputStream().close();

 }

 catch (Exception e)

 {

 e.printStackTrace();

 }

 }

 return null;

 }

 private static String substring(String src, int start_idx, int end_idx)

 {

 byte[] b = src.getBytes();

 String tgt = "";

 for (int i = start_idx; i <= end_idx; i++)

 {

 tgt += (char)b[i];

 }

 return tgt;

 }

 }