El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Creació de Fils

Següent ►
►

En aquest tema, aprendrem com crear i gestionar fils en Java. Els fils permeten executar múltiples tasques de manera concurrent, millorant l'eficiència i el rendiment de les aplicacions. Java proporciona diverses maneres de crear fils, i en aquesta secció explorarem les més comunes.

Objectius

  • Comprendre què és un fil i per què és útil.
  • Aprendre a crear fils utilitzant la classe Thread.
  • Aprendre a crear fils implementant la interfície Runnable.
  • Comparar les dues maneres de crear fils.
  • Realitzar exercicis pràctics per consolidar els coneixements.

Què és un Fil?

Un fil (thread) és una unitat d'execució dins d'un procés. Els fils permeten que un programa realitzi múltiples tasques al mateix temps. Això és especialment útil en aplicacions que requereixen operacions de llarg termini, com la lectura/escriptura de fitxers, operacions de xarxa, o càlculs intensius.

Creació de Fils amb la Classe Thread

Exemple Bàsic

La manera més directa de crear un fil és estendre la classe Thread i sobreescriure el mètode run.

class MyThread extends Thread {
    public void run() {
        System.out.println("El fil està en execució.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // Inicia el fil
    }
}

Explicació

  1. Estendre la Classe Thread: Creem una nova classe que estengui Thread.
  2. Sobreescriure el Mètode run: Implementem el codi que volem que s'executi en el fil dins del mètode run.
  3. Crear una Instància i Iniciar el Fil: Creem una instància de la nostra classe i cridem al mètode start per iniciar el fil.

Creació de Fils amb la Interfície Runnable

Exemple Bàsic

Una altra manera de crear un fil és implementant la interfície Runnable i passant una instància de la classe Runnable a un objecte Thread.

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("El fil està en execució.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // Inicia el fil
    }
}

Explicació

  1. Implementar la Interfície Runnable: Creem una nova classe que implementi Runnable.
  2. Implementar el Mètode run: Implementem el codi que volem que s'executi en el fil dins del mètode run.
  3. Crear una Instància de Runnable i Passar-la a un Objecte Thread: Creem una instància de la nostra classe Runnable i la passem al constructor de Thread.
  4. Iniciar el Fil: Cridem al mètode start de l'objecte Thread per iniciar el fil.

Comparació de les Dues Maneres

Mètode Avantatges Desavantatges
Estendre Thread - Més senzill per a fils simples. - No es pot estendre una altra classe.
Implementar Runnable - Permet estendre una altra classe.
- Millor separació de la lògica del fil.		 - Requereix més passos per crear i iniciar el fil.

Exercicis Pràctics

Exercici 1: Crear un Fil amb Thread

Descripció: Crea una classe que estengui Thread i imprimeixi els números de l'1 al 5.

class NumberThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        NumberThread thread = new NumberThread();
        thread.start();
    }
}

Exercici 2: Crear un Fil amb Runnable

Descripció: Crea una classe que implementi Runnable i imprimeixi els números de l'1 al 5.

class NumberRunnable implements Runnable {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        NumberRunnable numberRunnable = new NumberRunnable();
        Thread thread = new Thread(numberRunnable);
        thread.start();
    }
}

Errors Comuns i Consells

  • No Sobreescriure el Mètode run: Assegura't de sobreescriure el mètode run en lloc de crear un nou mètode.
  • No Cridar Directament al Mètode run: Cridar directament al mètode run no iniciarà un nou fil. Utilitza el mètode start per iniciar el fil.
  • Sincronització: Quan múltiples fils accedeixen a recursos compartits, pot ser necessari utilitzar mecanismes de sincronització per evitar condicions de carrera.

Conclusió

En aquesta secció, hem après com crear fils en Java utilitzant dues tècniques diferents: estendre la classe Thread i implementar la interfície Runnable. Hem vist exemples pràctics i hem realitzat exercicis per consolidar els coneixements. En la següent secció, explorarem el cicle de vida dels fils i com gestionar-los de manera eficient.

◄ Anterior
◄
Següent ►
►

Curs de Programació en Java

Mòdul 1: Introducció a Java

Mòdul 2: Flux de Control

Mòdul 3: Programació Orientada a Objectes

Mòdul 4: Programació Orientada a Objectes Avançada

Mòdul 5: Estructures de Dades i Col·leccions

Mòdul 6: Gestió d'Excepcions

Mòdul 7: Entrada/Sortida de Fitxers

Mòdul 8: Multithreading i Concurrència

Mòdul 9: Xarxes

Mòdul 10: Temes Avançats

Mòdul 11: Frameworks i Llibreries de Java

Mòdul 12: Construcció d'Aplicacions del Món Real

El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats