public void citesteFisier(String fileName) throws

IOException, ClassNotFoundException {
int ctr=0;
Scanner s1=new Scanner(new File(fileName));

while(s1.hasNextLine()) {
ctr=ctr+1;
s1.next();
}
stream=new int[ctr];

Scanner s2=new Scanner(new File(fileName));

for(int i=0;i<ctr;i++) {
stream[i]=s2.nextInt();
}
for(int i=0;i<stream.length;i++)
System.out.println(stream[i]);
}

extends Thread
implements Runnable acelasi lucru.
while true. si in main

@Override
public void run() {
try {
for (int i=0; i<5; i++) {
System.out.println(this.toString());
Thread.sleep(this.timpDeLucru);
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
 e.printStackTrace();
}
}

t1.start();
t2.start();

runn
Runnable r1 = new DeparteAproape("aproape", 50);
Runnable r2 = new DeparteAproape("DEPARTE", 100);

// new Thread(r1).start();
// new Thread(r2).start();

Thread t1 = new Thread(r1);

Thread t2 = new Thread(r2);

t1.start();
t2.start();

package multithreading_2;

public class Cont {

private double sold;
private boolean operare;

public Cont (double suma) {

this.sold = suma;
this.operare = false;
}

public boolean isInOperare() {

 return this.operare;
}

public void setOperare(boolean stare) {

this.operare = stare;
}

public double getSold() {

return this.sold;
}

public double depunere(double suma) {

this.sold += suma;
return sold;
}

public double retragere(double suma) {

if (suma <= this.sold) {
this.sold -= suma;
return this.sold;
}

return -1;
}
}

package multithreading_2;

public class OperatorBancar extends Thread {

private Cont cont;
private String numeOperator;
private int timpOperare;
private double suma;
/**
* @param cont
* @param numeOperator
* @param timpOperare
 * @param suma
*/
public OperatorBancar(Cont cont, String numeOperator,
int timpOperare, double suma) {
super();
this.cont = cont;
this.numeOperator = numeOperator;
this.timpOperare = timpOperare;
this.suma = suma;
}

@Override
public void run() {
while (true) {
try {
Thread.sleep(this.timpOperare);
operareCont(suma);
} catch (InterruptedException e) {
// Nu fac nimic, ci doar returnez
return;
}
}
}

public void operareCont(double suma) {

try {
synchronized (this) {
if (cont.isInOperare())
wait();

cont.setOperare(true);
System.out.println("Soldul inainte de
operare " +
numeOperator + ": " +
cont.getSold());

// cont.depunere(suma);
if (cont.retragere(suma) < 0) {
 System.out.println("Intrerupere
pentru suma: " +
suma);
eliberareCont();
Thread.currentThread().interrupt();
}

eliberareCont();
}
} catch (InterruptedException e) {
// System.out.println("Intrerupere pentru suma: "
+
// suma);
// eliberareCont();
}
}

public void eliberareCont() {

if (cont.isInOperare()) {
System.out.println("Soldul dupa operare " +
numeOperator + ": " +
cont.getSold());
System.out.println();

cont.setOperare(false);

notifyAll();
}
}

public static void main(String[] args) {

Cont cont = new Cont(100);

OperatorBancar operatorA = new OperatorBancar(cont,

"A", 500, 10);
OperatorBancar operatorB = new OperatorBancar(cont,
"B", 100, 1);
OperatorBancar operatorC = new OperatorBancar(cont,
"C", 200, 5);
 operatorA.setName("A");
operatorB.setName("B");
operatorC.setName("C");

operatorA.start();
operatorB.start();
operatorC.start();

Thread[] threadArray = new

Thread[Thread.activeCount()];
Thread.enumerate(threadArray);

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

System.out.println(threadArray[i].getName() +
" cu prioritatea " +
threadArray[i].getPriority());
}

try {
operatorA.join();
operatorB.join();
operatorC.join();
// Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

// operatorA.interrupt();
// operatorB.interrupt();
// operatorC.interrupt();

System.out.println("Sold final in main: " +

cont.getSold());
}
}
package multithreading_3;

import java.util.concurrent.Semaphore;

public class ContCuSemafor {

private double sold;
private Semaphore operare;
private int nrMaxOperatori; // acest atribut nu are o
utilizare imediata

public ContCuSemafor(double suma,

int nrMaxOperatori) {
this.sold = suma;
this.nrMaxOperatori = nrMaxOperatori;
this.operare = new Semaphore(nrMaxOperatori);
}

public synchronized double getSold() {

return this.sold;
}

public synchronized void depunere(double suma) {

this.sold += suma;
}

public synchronized double retragere(double suma) {

if (this.sold >= suma) {
this.sold -=suma;
return this.sold;
}

return -1;
}

public synchronized boolean isInOperare() {

return this.operare.tryAcquire();
}

public synchronized void ReleaseOperare() {

 this.operare.release();
}

public synchronized void AquireOperare() {

try {
this.operare.acquire();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

package multithreading_3;

public class OperatorBancarCuSemafor extends Thread {

private ContCuSemafor cont;
private String numeOperator;
private int timpOperare;
private double suma;

public OperatorBancarCuSemafor(ContCuSemafor cont,

String numeOperator,
int timpOperare,
double suma) {
super();
this.cont = cont;
this.numeOperator = numeOperator;
this.timpOperare = timpOperare;
this.suma = suma;
}

@Override
public void run() {
try {
 while (true) {
Thread.sleep(timpOperare);
// synchronized(this) {
operareCont(suma);
// }
}
} catch (InterruptedException e) {
// Nu am nimic de facut
return;
}
}

private void operareCont(double suma) {

synchronized (this) {
if (cont.isInOperare()) {

System.out.println("Sold inainte de
operare " +
this.numeOperator + ": " +
this.cont.getSold());

// if (cont.getSold() < 200) {

// cont.depunere(suma);
// } else {
// System.out.println("Operator " +
// this.numeOperator + " a fost
intrerupt");
// eliberareCont();
// Thread.currentThread().interrupt();
// }

if (cont.retragere(suma) < 0) {
System.out.println("Operator " +
this.numeOperator + " a fost
intrerupt");
eliberareCont();
Thread.currentThread().interrupt();
}
 eliberareCont();
}
}
}

private void eliberareCont() {

// synchronized(this) {
System.out.println("Sold dupa operare " +
this.numeOperator + ": " +
this.cont.getSold());
System.out.println();

cont.ReleaseOperare();
// }
}

public static void main(String[] args) {

ContCuSemafor cont = new ContCuSemafor(100, 10);

OperatorBancarCuSemafor operatorA = new

OperatorBancarCuSemafor(cont,
"A", 500, 10);
OperatorBancarCuSemafor operatorB = new
OperatorBancarCuSemafor(cont,
"B", 100, 1);
OperatorBancarCuSemafor operatorC = new
OperatorBancarCuSemafor(cont,
"C", 200, 5);

operatorA.setName("Thread A");
operatorB.setName("Thread B");
operatorC.setName("Thread C");

operatorC.setPriority(MAX_PRIORITY);

operatorA.start();
operatorB.start();
operatorC.start();
 Thread[] threadArray = new
Thread[Thread.activeCount()];
Thread.enumerate(threadArray);
for (int i=0; i<threadArray.length; i++)
System.out.println(threadArray[i].getName() +
" cu prioritatea " +
threadArray[i].getPriority());

try {
// sleep(3000);
operatorA.join();
operatorB.join();
operatorC.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

System.out.println("Sold final in master: " +

cont.getSold());
}
}

float a=0, b=0;

InputStreamReader reader=new
InputStreamReader(System.in);
BufferedReader br=new BufferedReader(reader);
System.out.println("a=");

try {
String input=br.readLine();
a=Float.parseFloat(input);
} catch (IOException e) {

e.printStackTrace();
}
System.out.println("b=");
try {
 String input=br.readLine();
b=Float.parseFloat(input);
} catch (IOException e) {

e.printStackTrace();
}
catch(NumberFormatException e) {
System.out.println("Number is not in proper
format");
e.printStackTrace();
}
System.out.println("a +b =" +(a+b));

FileOutputStream fos=null;
OutputStreamWriter writer=null;
try {
fos=new FileOutputStream("robot.txt");
writer=new OutputStreamWriter(fos);
writer.write(robot.getName()+ "");
writer.write(System.lineSeparator());
writer.write(String.format("%.2f",
robot.getAutonomy()));
writer.write(System.lineSeparator());
writer.write(String.format("%d",
robot.getProductionYear()));
} catch (IOException e) {

e.printStackTrace();
}
finally {
if(writer !=null) {
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fos !=null) {
 try {
fos.close();
} catch (IOException e) {

e.printStackTrace();
}
}
}

try(FileInputStream fis=new
FileInputStream("robot.txt")){
try(InputStreamReader is=new
InputStreamReader(fis)){
try(BufferedReader buffer=new
BufferedReader(is)){

System.out.println(buffer.readLine());
System.out.println(buffer.readLine());
System.out.println(buffer.readLine());
}
}
}
catch(IOException e ) {
e.printStackTrace();
}