Examen 2025-26

package fr.unantes.sce.patterns.thread.enumeration;

public class Thread {
    enum State {BLOCKED,INTERRUPT,READY,RUNNING,TERMINATED}

    private State state = State.READY;

    public void interrupt() {
        if (this.state != State.RUNNING) {
            throw  new IllegalStateException();
        }
        // Do interrupt behavior
        this.state = State.TERMINATED;
    }

    public void run() {
        if (this.state != State.READY) {
            throw  new IllegalStateException();
        }
        // Do run behavior
        this.state = State.RUNNING;
    }

    public void sleep() {
        if (this.state != State.RUNNING) {
            throw  new IllegalStateException();
        }
        // Do sleep behavior
        this.state = State.BLOCKED;
    }

    public void timeout() {
        if (this.state != State.BLOCKED) {
            throw  new IllegalStateException();
        }
        // Do timeout behavior
        this.state = State.RUNNING;
    }
}

package fr.unantes.sce.patterns.thread.state;

public class Thread {
    private ThreadState state = new Ready(this);

    public void interrupt() {
        this.state.interrupt();
    }

    public void run() {
        this.state.run();
    }

    public void sleep(int millis) {
        this.state.sleep(millis);
    }

    void setStateRunning() {
        state = new Running(this);
    }

    void setStateBlocked() {
        state = new Blocked(this);
    }

    void setStateTerminated() {
        state = new Terminated(this);
    }
}

package fr.unantes.sce.patterns.thread.state;

public interface ThreadState {

    public default void interrupt() {
        throw new IllegalStateException();
    }

    public default void run() {
        throw new IllegalStateException();
    }

    public default void sleep(int millis) {
        throw new IllegalStateException();
    }
}

package fr.unantes.sce.patterns.thread.state;


public abstract class CommonState {
    private final Thread thread;

    public CommonState(Thread thread) {
        this.thread = thread;
    }

    Thread thread() {
        return thread;
    }
}

package fr.unantes.sce.patterns.thread.state;

public class Ready extends CommonState implements ThreadState {

    public Ready(Thread thread) {
        super(thread);
    }

    public void run() {
        // run method behavior
        thread().setStateRunning();
    }
}

package fr.unantes.sce.patterns.thread.state;

import java.lang.Thread;

public class Blocked extends CommonState implements ThreadState {

    public Blocked(Thread thread) {
        super(thread);
    }

    public void timeout() {
        thread().setStateRunning();
    }
}

package fr.unantes.sce.patterns.thread.state;

import java.lang.Thread;

public class Terminated extends CommonState implements ThreadState {
    public Terminated(Thread thread) {
        super(thread);
    }
}

package fr.unantes.sce.patterns.thread.state;

import java.lang.Thread;

public class Running extends CommonState implements ThreadState {

    public Running(Thread thread) {
        super(thread);
    }

    public void interrupt() {
        // Interrupt behavior
        thread().setStateTerminated();
    }

    public void sleep() {
        // Sleep behavior
        thread().setStateBlocked();
    }
}