Intrri/ieiri la nivel sczut

Java NIO

Java NIO ofer o alternativ de nivel sczut pentru operaiunile de IO

Java NIO folosete n principal clase de tip Buffer i Channel pentru
citirea/scrierea datelor
Java NIO permite realizarea unor operaiuni de intrare/ieire asincrone
Implementeaz conceptul de selector. Un obiect selector poate
monitoriza canale multiple pe un singur fir de execuie

Implementri Channel
Un obiect Channel reprezint o conexiune deschis la o entitate, cum ar fi un
fiier, un socket, sau orice component capabila de a efectua operaii de
intrare/iesire, citire/scriere
Diferene Channel-Stream:
obiectul Channel este bidirecional , Stream este unidirecional
obiectul Channel scrie/citete asincron
Implementri Channel:
FileChannel - citire/scriere din/n fiiere
DatagramChannel - citire/scriere din/n reea utiliznd UDP
SocketChannel - citire/scriere din/n reea utiliznd TCP
ServerSocketChannel - permite crearea unui server TCP pentru
citiri/scrieri n reea

FileChannel
Obtinerea obiectelor Channel
prin metodele open definite in Channel
public static FileChannel open(Path path, OpenOption... options) throws
IOException
unde options pot fi APPEND, CREATE, CREATE_NEW,... constante definite
in StandardOpenOption
prin obiectele Stream: FileInputStream, FileOutputStream
public FileChannel getChannel()
prin obiecte RandomAccessFile
public final FileChannel getChannel()
Transferul intre obiecte Channel
public abstract long transferFrom(ReadableByteChannel src, long position,
long count) throws IOException
public abstract long transferTo(long position,long count,WritableByteChannel
target) throws IOException; // Transfer spre target. position,count se refera
la canalul curent

Implementri Buffer
ByteBuffer , MappedByteBuffer , CharBuffer , DoubleBuffer , FloatBuffer ,
IntBuffer , LongBuffer , ShortBuffer
Un Buffer este un bloc de memorie in care se pot scrie date care apoi pot fi
citite.
Proprietatile unui Buffer:
capacity - dimensiunea maxima a Buffer-ului
position - este indexul urmtorului element care poate fi citit sau scris la un
moment dat
limit - este indicele primului element care nu poate fi scris/citit
mark - este un marcaj de pozitie retinut pentru reveniri ulterioare
0 <= mark <= position <= limit <= capacity
Operaiuni Buffer:
1. Alocarea se face prin metoda statica allocate a clasei Buffer (ByteBuffer,
DoubleBuffer, ...):
public static ByteBuffer allocate(int capacity)

Metode de scriere/citire
2. Scrierea datelor in Buffer din Channel prin metode read ale clasei
FileChannel:
public abstract int read(ByteBuffer dst) throws IOException; // intoarce
numarul de bytes cititi. Dupa citire: position=limit
3. Scrierea voluntar in buffer prin metode put ale bufferului:
public abstract ByteBuffer put(byte b); // scrie la pozitia curenta cu
incrementarea pozitiei
public abstract ByteBuffer put(int index, byte b);// scrie la pozitia indicata
4. Citirea din Buffer si scrierea in Channel:
public abstract int write(ByteBuffer src) throws IOException; // intoarce
numarul de bytes cititi din src de pe pozitia curenta -> position=limit
5. Citirea voluntar din Buffer prin metode get ale bufferului:
public abstract byte get(); //citire de la pozitia curenta cu incrementarea
pozitiei
public abstract byte get(int index); //citire de la pozitia indicata

Strile Buffer
7. Trecerea Buffer-ului din modul scriere n modul citire:
public final Buffer flip(); //limit=position, position=0
8. Stergere Buffer
public final Buffer clear(); //position=0, limit=capacity - Pregatire scriere/citire
in/din buffer
public final Buffer rewind(); //position=0
public final Buffer mark(); // este marcata pozitia curenta, mark=position
public final Buffer reset(); // este stabilita pozitia pe marcajul precedent,
position=mark

Serializarea
Transformarea datelor n secvene de octei
astfel nct s poat fi transmise pe un flux de
ieire
Deserializare - procesul invers

Scopul serializrii
transmiterea datelor la distan. RMI
conservarea datelor n afara timpului de
execuie. Persistena obiectelor
asigurarea portabilitii datelor sub diverse SO
implementarea tehnologiei bazate pe
componente reutilizabile - Beans

Mecanisme de serializare
Mecanismul implicit de serializare prin implementarea
interfetei Serializable
Serializarea voluntara prin redefinirea metodelor readObject
si writeObject. Semntura exact a metodelor este:
private void readObject(java.io.ObjectInputStream stream)
throws IOException, ClassNotFoundException;
private void writeObject(java.io.ObjectOutputStream stream)
throws IOException
Serializarea explicita utilizand interfata Externalizable

Interfee, clase

public interface ObjectInput extends DataInput

public interface ObjectOutput extends DataOutput
public class ObjectInputStream extends InputStream
implements ObjectInput, ObjectStreamConstants
public class ObjectOutputStream extends OutputStream
implements ObjectOutput, ObjectStreamConstants

public interface Serializable

public interface Externalizable extends
Serializable

ObjectOutputStream
Clasa utilizat pentru construirea fluxurilor de scriere
(serializare)
Constructor:
public ObjectOutputStream(OutputStream out) throws
IOException
Metode pentru scriere obiecte:
public final void writeObject(Object obj) throws IOException
public void defaultWriteObject() throws IOException

ObjectInputStream
Clas utilizat pentru construirea fluxurilor de intrare
(deserializare).
Constructor:
public ObjectInputStream(InputStream in) throws IOException

Metode:
public final Object readObject() throws IOException,
ClassNotFoundException
public void defaultReadObject() throws IOException,
ClassNotFoundException

Externalizable
Interfa utilizat pentru serializarea explicit. Folosirea interfeei
impune existena unui constructor fr parametrii.
Implementarea const n implementarea metodelor:
public void writeExternal(ObjectOutput out) throws
IOException
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException

Domeniul calculului paralel

Limbaje:
Limbaje care contin constructii pentru a exprima concepte de
programare paralela
Compilatoare:
compilatoare pentru limbaje paralele
Supercompilatoare: traslateaza cod secvential in cod paralel
Algoritmi:
Dezvoltarea unor noi algoritmi pentru noile arhitecturi paralele
Dezvoltarea de biblioteci
Aplicatii
Aplicatii stiintifice si ingineresti: dinamica fluidelor, stiinta materialelor,
studiul atmosferei, biologie
Aplicatii din economie, stiinte sociale
Inteligenta artificiala: retele neuronale, cautare
Grafica, multimedia, realitate virtuala
Motoare de cautare (AltaVista, Google etc.)

Calcul paralel - calcul distribuit

Sistem de calcul paralel

Sistem distribuit

Procesoarele sunt, de obicei, de

acelasi tip

Procesoarele sunt, de obicei,

eterogene

Procesoarele sunt, de obicei,

distribuite pe o arie geografica
mica

Procesoarele sunt, de obicei,

distribuite pe o arie geografica
mare

Scopul: executarea unor calcule

mai rapid decat cu un singur
procesor

Scopul: utilizarea in comun a

resurselor disponibile,
transmiterea informatiilor.
Probleme specifice:
fiabilitate, securitate

Fire de executie in Java

Algoritm paralel = algoritm care permite efectuarea simultana a mai multor operatii
prin descompunerea unei probleme in subprobleme care se executa in paralel pe
mai multe procesoare
Firul de execuie specifica executia secventiala a unui set de instructiuni
Proces: mulime de fire de execuie care se execut ntr-un cadru paralel real sau
simulat
Paralelism logic: 1 procesor N procese.
La un moment dat se executa fizic o actiune corespunzatoare unui singur
proces.
Procesele se desfasoara concurent: se lanseaza instructiunile unui proces
inainte de a se fi terminat executia tuturor instructiunilor corespunzatoare
celorlalte procese
Paralelism fizic: 1 procesor 1 proces.

Java Threading API

Crearea unui fir de execuie in Java

extinderea clasei Thread
implementarea interfeei Runnable

Extinderea clasei Thread

crearea unei clase derivate din Thread
suprascrierea metodei run()
instanerea unui obiect din clasa creat
pornirea thread-ului prin invocarea metodei start()

Implementarea interfeei Runnable

crearea unei clase care implementeaz Runnable

implementarea metodei run()
instanierea clasei Runnable create
crearea unui obiect al clasei Thread printr-un constructor care primete
obiectul Runnable
pornire thread prin start()

public class Thread extends Object

implements Runnable
Constructori
public Thread();
public Thread(Runnable target); public Thread(ThreadGroup group,
Runnable target);
public Thread(String name);
public Thread(ThreadGroup group, String name)
public Thread(Runnable target, String name)
public Thread(ThreadGroup group, Runnable target, String name);
unde:
target - obiect Runnable care contine metoda run a firului creat;
name - nume asociat firului
group - grupul de fire la care este asociat firul creat

Metode:
public static Thread currentThread(); // referinta la firul caruia ii apartine
codulcurent
public static int activeCount(); // numarul de fire active
public final ThreadGroup getThreadGroup(); // grupul caruia ii apartine
firul curent
public static int enumerate(Thread[] tarray); // metoda ThreadGroup care
intoarce in tarray referinta la firele din grup
public final int getPriority(); // prioritatea pe o scara [1-10]
public final String getName() ; // numele asociat firului
public final void setName(String name)
public final void setPriority(int newPriority)

Strile unui fir de execuie

Ready
Running
Blocked
Sleeping
Waiting
Dead

Comutarea starilor

public void start();

public void run() ;
public static void yield() ;
public static void sleep(long millis) throws
InterruptedException ;
public static void sleep(long millis, int nanos) throws
InterruptedException ;

Prioritaile firelor de execuie

public final static int MAX_PRIORITY; // = 10;

public static final int MIN_PRIORITY; // =1
public static final int NORM_PRIORITY; // = 5
public static void yield(); // trecere voluntara din starea running in starea
ready

Planificarea firelor
preemtiva trecerea automata n execuie a firelor cu priritate mai mare
round-robin execturea firelor dup cuante de timp alocate