language: java

jdk:

- oraclejdk8

[](https://travis-ci.org/chrishantha/sample-java-programs)

This repository contains some sample programs. All are Maven projects and can be run directly using "java -jar"

**highcpu**

A java program consuming high CPU usage. This program was inspired by a sample found in the article "[Identifying which Java Thread is consuming most CPU](http://code.nomad-labs.com/2010/11/18/identifying-which-java-thread-is-consuming-most-cpu/)"

Copyright (C) 2015 M. Isuru Tharanga Chrishantha Perera

Licensed under the Apache License, Version 2.0

<?xml version="1.0" encoding="utf-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

<parent>

<groupId>com.github.chrishantha.sample</groupId>

<artifactId>java-samples</artifactId>

<version>0.0.1-SNAPSHOT</version>

</parent>

<modelVersion>4.0.0</modelVersion>

<artifactId>highcpu</artifactId>

<packaging>jar</packaging>

<name>highcpu</name>

<dependencies>

<dependency>

<groupId>com.beust</groupId>

<artifactId>jcommander</artifactId>

</dependency>

</dependencies>

<properties>

<fully.qualified.main.class>com.github.chrishantha.sample.highcpu.App</fully.qualified.main.class>

</properties>

</project>

package com.github.chrishantha.sample.highcpu;

import java.util.Timer;

import java.util.TimerTask;

import com.beust.jcommander.JCommander;

import com.beust.jcommander.Parameter;

public class App {

@Parameter(names = "--run-hashing", description = "Run Hashing Worker", arity = 1)

private boolean runHashing = true;

@Parameter(names = "--run-sleeping", description = "Run Sleeping Worker", arity = 1)

private boolean runSleeping = true;

@Parameter(names = "--run-math", description = "Run Math Worker", arity = 1)

private boolean runMath = true;

@Parameter(names = "--hashing-workers", description = "Hashing Workers")

private int hashingWorkers = 1;

@Parameter(names = "--sleeping-workers", description = "Sleeping Workers")

private int sleepingWorkers = 3;

@Parameter(names = "--math-workers", description = "Math Workers")

private int mathWorkers = 2;

@Parameter(names = "--hash-data-length", description = "Hash Data Length")

private long hashDataLength = 2000;

@Parameter(names = "--hashing-algo", description = "Hashing Algorithm")

private String hashingAlgorithm = "SHA-1";

@Parameter(names = "--help", description = "Display Help", help = true)

private boolean help;

@Parameter(names = "--exit-timeout", description = "Exit Timeout in Seconds (Default 2 minutes. Use 0 to run forever)")

private int exitTimeoutInSeconds = 2 * 60;

public static void main(String[] args) {

App app = new App();

final JCommander jcmdr = new JCommander(app);

jcmdr.setProgramName(App.class.getSimpleName());

jcmdr.parse(args);

if (app.help) {

jcmdr.usage();

return;

}

app.start();

}

private void start() {

System.out.println("Starting Application...");

if (exitTimeoutInSeconds > 0) {

final Timer timer = new Timer();

timer.schedule(new TimerTask() {

public void run() {

System.out.println("Exiting now...");

System.exit(0);

}

}, exitTimeoutInSeconds * 1000);

}

if (runHashing) {

for (int i = 0; i < hashingWorkers; i++) {

startThread(i, "Hashing", new HashingWorker(hashDataLength, hashingAlgorithm));

}

}

if (runSleeping) {

for (int i = 0; i < sleepingWorkers; i++) {

startThread(i, "Sleeping", new SleepingWorker());

}

}

if (runMath) {

for (int i = 0; i < mathWorkers; i++) {

startThread(i, "Math", new MathWorker());

}

}

}

private void startThread(int i, String name, Runnable worker) {

Thread thread = new Thread(new HashingWorker(hashDataLength, hashingAlgorithm));

thread.setName(String.format("Thread %d: %s", i, name));

thread.start();

}

}

package com.github.chrishantha.sample.highcpu;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.UUID;

public class HashingWorker implements Runnable {

private final String algorithm;

private final long length;

public HashingWorker(long length, String algorithm) {

this.length = length;

this.algorithm = algorithm;

}

@Override

public void run() {

while (true) {

String data = "";

// Some random data

for (int i = 0; i < length; i++) {

data += UUID.randomUUID().toString();

}

MessageDigest digest;

try {

digest = MessageDigest.getInstance(algorithm);

} catch (NoSuchAlgorithmException e) {

throw new RuntimeException(e);

}

// Hash

digest.update(data.getBytes());

}

}

}

package com.github.chrishantha.sample.highcpu;

import java.math.BigDecimal;

import java.util.Random;

public class MathWorker implements Runnable {

private Random random = new Random();

public MathWorker() {

}

@Override

public void run() {

while (true) {

BigDecimal sum = BigDecimal.ZERO;

for (int i = 0; i <= Integer.MAX_VALUE; i++) {

double value = Math.atan(Math.sqrt(Math.pow(random.nextInt(10), random.nextDouble())));

sum = sum.add(BigDecimal.valueOf(value));

}

}

}

}

package com.github.chrishantha.sample.highcpu;

import java.util.Random;

public class SleepingWorker implements Runnable {

private Random random = new Random();

public SleepingWorker() {

}

@Override

public void run() {

Long l = 0l;

while (true) {

l++;

try {

Thread.sleep(random.nextInt(20));

} catch (InterruptedException e) {

e.printStackTrace();

}

if (l == Long.MAX_VALUE) {

l = 0l;

}

}

}

}