Alcune soluzioni proposte
Tasks e Threads
PrintTask
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class PrintTask implements Runnable
{
private int id;
private int max;
private static Random generator = new Random();
public PrintTask(int id, int max)
{
this.id = id;
this.max = max;
}
public void run()
{
for(int i = 0; i < max; i++)
{
System.out.println(i + "[Task" + id + "]");
try
{
Thread.sleep(generator.nextInt(1000));
}catch(InterruptedException exception)
{
exception.printStackTrace();
}
}
}
public static void main(String[] args)
{
int nTasks = 5;
int max = 10;
if(args.length > 1)
{
nTasks = Integer.parseInt(args[0]);
max = Integer.parseInt(args[1]);
}
ExecutorService threadExecutor = Executors.newCachedThreadPool();
for(int i = 0; i < nTasks; i++)
threadExecutor.execute(new PrintTask(i, max));
threadExecutor.shutdown();
}
}
SleepTask
public class SleepTask implements Runnable
{
private long start = 0;
private long end = 0;
private final long SLEEP_TIME = 10000;
public void run()
{
try
{
start = System.currentTimeMillis();
Thread.sleep(SLEEP_TIME);
}catch(InterruptedException x)
{
end = System.currentTimeMillis();
System.out.println("TaskSleep - interrotto dopo " + (end - start) + " ms");
}
}
public static void main(String[] args)
{
final long MAX_TIME = 5000;
SleepTask task = new SleepTask();
Thread t = new Thread(task);
System.out.println("main - avvio il thread");
t.start();
try
{
Thread.sleep(MAX_TIME);
}catch(InterruptedException x){}
System.out.println("main - eseguo la interrupt sul thread");
t.interrupt();
System.out.println("main - fine del main");
}
}
PITask2
public class PITask2 implements Runnable
{
private double piEstimate = 0.0;
private long iteration = 0;
private int sign = -1;
private double accuracy;
private Thread main;
public PITask2(double accuracy, Thread main)
{
this.accuracy = accuracy;
this.main = main;
}
public void run()
{
System.out.println("Valore di Math.PI = " + Math.PI);
while(!Thread.currentThread().isInterrupted()
&& Math.abs(piEstimate - Math.PI) > accuracy)
{
iteration++;
sign = -sign;
piEstimate += sign * 4.0 / ((2 * iteration) - 1);
}
if(Math.abs(piEstimate - Math.PI) > accuracy)
System.out.println("Thread interrotto");
else
main.interrupt();
System.out.println("Valore calcolato di PI = " + piEstimate);
}
public static void main(String[] args)
{
double accuracy = 0.000000001;
long sleepTime = 5000;
if(args.length > 1)
{
accuracy = Math.pow(10, -1 * Integer.parseInt(args[0]));
sleepTime = Integer.parseInt(args[1]) * 1000;
}
System.out.println("Accuracy = " + accuracy);
PITask2 task = new PITask2(accuracy, Thread.currentThread());
Thread t = new Thread(task);
t.start();
try
{
t.join(sleepTime);
if(t.isAlive()) t.interrupt();
}catch(InterruptedException x)
{
System.out.println("Main interrotto");
}
System.out.println("Fine main");
}
}
Thread Pool
AsynchronousCalculator
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.concurrent.*;
public class AsynchronousCalculator
{
public static void main(String[] args)
{
ExecutorService exec = Executors.newCachedThreadPool();
boolean quit = false;
while(!quit)
{
System.out.println("Inserisci l'espressione:");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = null;
try
{
s = br.readLine();
}catch(IOException e)
{
e.printStackTrace();
return;
}
if(s.startsWith("PI:"))
{
int value;
try
{
value = Integer.parseInt(s.substring(s.indexOf(':') + 1, s.length()));
}catch(Exception e)
{
System.out.println("Espressione non valida");
continue;
}
exec.execute(new PITask(value));
}
else if(s.startsWith("FIB:"))
{
int value;
try
{
value = Integer.parseInt(s.substring(s.indexOf(':') + 1, s.length()));
}catch(Exception e)
{
System.out.println("Espressione non valida");
continue;
}
exec.execute(new FibTask(value));
}
else if(s.startsWith("FACT:"))
{
int value;
try
{
value = Integer.parseInt(s.substring(s.indexOf(':') + 1, s.length()));
}catch(Exception e)
{
System.out.println("Espressione non valida");
continue;
}
exec.execute(new FactTask(value));
}
else if(s.equalsIgnoreCase("QUIT"))
{
quit = true;
}
else
{
System.out.println("Espressione non valida");
}
}
exec.shutdown();
System.out.println("Main esce");
}
}
Task
import java.text.SimpleDateFormat;
import java.util.Date;
public abstract class Task implements Runnable
{
public long creationTime;
public long startTime;
public long endTime;
public String result;
public Task()
{
this.creationTime = System.currentTimeMillis();
}
public abstract void compute();
public void setResult(String result)
{
this.result = result;
}
public void run()
{
this.startTime = System.currentTimeMillis();
compute();
this.endTime = System.currentTimeMillis();
printResult();
}
public void printResult()
{
SimpleDateFormat formatter = new SimpleDateFormat("E, dd MMM yyyy HH:mm:ss:SS");
String creationString = formatter.format(new Date(this.creationTime));
String startString = formatter.format(new Date(this.startTime));
String endString = formatter.format(new Date(this.endTime));
System.out.println(Thread.currentThread().getName()
+ ", creationTime = " + creationString + ", startTime = "
+ startString + ", endTime = " + endString + ", " + result);
}
}
PITask
public class PITask extends Task
{
private double piEstimate = 0.0;
private long iteration = 0;
private int sign = -1;
private double accuracy;
public PITask(int precision)
{
this.accuracy = Math.pow(10, -1 * precision);
}
public void compute()
{
while(Math.abs(piEstimate - Math.PI) > accuracy)
{
iteration++;
sign = -sign;
piEstimate += sign * 4.0 / ((2 * iteration) - 1);
}
setResult("Pigreco = " + piEstimate + ", accuracy = " + this.accuracy);
}
}
FibTask
public class FibTask extends Task
{
int value;
public FibTask(int value)
{
this.value = value;
}
private int fib(int n)
{
if(n == 0 || n == 1) return n;
if(n == 1) return 1;
return fib(n - 1) + fib(n - 2);
}
public void compute()
{
int result = this.fib(value);
setResult("Fib(" + value + ") = " + result);
}
}
FactTask
public class FactTask extends Task
{
int value;
public FactTask(int value)
{
this.value = value;
}
private long fact(int n)
{
if(n == 0) return 1;
if(n == 1) return 1;
return(n * fact(n - 1));
}
public void compute()
{
long result = this.fact(value);
setResult("Fact(" + value + ") = " + result);
}
}
Indirizzi IP
ListInterface
import java.util.Enumeration;
import java.net.*;
public class ListInterface
{
public static void main(String[] args)
{
try
{
Enumeration<NetworkInterface> interfaceList = NetworkInterface.getNetworkInterfaces();
if(interfaceList == null)
{
System.out.println("Nessuna interfaccia di rete disponibile");
}
else
{
while(interfaceList.hasMoreElements())
{
NetworkInterface iface = interfaceList.nextElement();
System.out.println("Interface " + iface.getName() + ":->" + iface.getDisplayName());
Enumeration<InetAddress> addrList = iface.getInetAddresses();
while(addrList.hasMoreElements())
{
InetAddress address = addrList.nextElement();
System.out.print("\tIndirizzo " + ((address instanceof Inet4Address ? "(v4)"
: (address instanceof Inet6Address ? "(v6)" : "(?)"))));
System.out.println(": " + address.getHostAddress());
}
}
}
}catch(SocketException e) { System.out.println(e);}
}
}