Torna alla pagina degli esercizi proposti

FAQ

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();
	}
}

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");
	}
}

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");
	}
}

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");
	}
}

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);
	}
}

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);
	}
}

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);
	}
}

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);
	}
}

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);}
    }
}