Esercizio Thread

Realizzare la classe thread-safe Market, che permette a diversi thread di contrattare il prezzo
di un servizio. Il metodo sell ore il servizio per un certo prezzo e blocca il chiamante nché
non arriverà una richiesta con un importo adeguato. Simmetricamente, il metodo buy richiede il
servizio per un certo prezzo e blocca il chiamante nché non arriverà un'oerta adeguata.
Per semplicità, si può supporre che tutti gli importi passati a sell e buy siano diversi.
L'implementazione deve rispettare il seguente esempio d'uso, in cui diversi thread condividono
un oggetto Market m:
Output
Thread 1: m.buy(10.0); resta bloccato
Thread 2: m.sell (15.50); resta bloccato
Thread 3: m.sell (12.0) ; resta bloccato
Thread 4: m.buy(13.0); sblocca T3 e ritorna
Thread 5: m.buy(11.0); resta bloccato
Thread 6: m.sell (9.50) ; sblocca T1 oppure T5 e ritorna

import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;

public class  Market {

    List<Double> listBuy;
    List<Double> listSell;

    Map<Thread,Double> mapBuy;
    Map<Thread,Double> mapSell;

    public Market(){
        listBuy = new ArrayList<>();
        listSell = new ArrayList<>();

        mapBuy = new HashMap<>();
        mapSell = new HashMap<>();
    }

    public synchronized void buy(Double b){
        try {
            if (mapSell.isEmpty()) {
                mapBuy.put(Thread.currentThread(),b);
                System.out.println(Thread.currentThread().getName() + " resta bloccato");
                this.wait();
//                System.out.println("Sblocca " + Thread.currentThread().getName() + " e ritorna");
//                mapBuy.remove(Thread.currentThread());
//                return;
            }else{
                for(Thread curr : mapSell.keySet()){
                    if(b>mapSell.get(curr)){
                        curr.interrupt();
                        mapSell.remove(curr);
                        return;
                    }
                }
                mapBuy.put(Thread.currentThread(),b);
                System.out.println(Thread.currentThread().getName() + " resta bloccato");
                this.wait();
//                System.out.println("Sblocca " + Thread.currentThread().getName() + " e ritorna");
//                mapBuy.remove(Thread.currentThread());
//                return;
            }
        }catch(InterruptedException e){
            System.out.println("Sblocca " + Thread.currentThread().getName() + " e ritorna");
            mapBuy.remove(Thread.currentThread());
            return;

        }
    }
    public synchronized void sell(Double s){
        try{
            if(mapBuy.isEmpty()){
                mapSell.put(Thread.currentThread(),s);
                System.out.println(Thread.currentThread().getName() + " resta bloccato");
                this.wait();
//                System.out.println("Sblocca " + Thread.currentThread().getName() + " e ritorna");
//                mapSell.remove(Thread.currentThread());
//                return;
            }else{
                for(Thread curr : mapBuy.keySet()){
                    if(s<mapBuy.get(curr)){
                        curr.interrupt();
                        mapBuy.remove(curr);
                        return;
                    }
                }
                mapSell.put(Thread.currentThread(),s);
                System.out.println(Thread.currentThread().getName() + " resta bloccato");
                this.wait();
//                System.out.println("Sblocca " + Thread.currentThread().getName() + " e ritorna");
//                mapSell.remove(Thread.currentThread());
            }
        }catch(InterruptedException e){
            System.out.println("Sblocca " + Thread.currentThread().getName() + " e ritorna");
            mapSell.remove(Thread.currentThread());
            return;
        }
    }

    public static void main(String[] args) {

        Market m = new Market();

        Thread myThread1 = new Thread("T1"){
            @Override
            public void run() {
                m.buy(10.0);
            }
        };
        Thread myThread2 = new Thread("T2"){
            @Override
            public void run() {
                m.sell(15.50);
            }
        };
        Thread myThread3 = new Thread("T3"){
            @Override
            public void run() {
                m.sell(12.0);
            }
        };
        Thread myThread4 = new Thread("T4"){
            @Override
            public void run() {
                m.buy(13.0);
            }
        };
        Thread myThread5 = new Thread("T5"){
            @Override
            public void run() {
                m.buy(11.0);
            }
        };
        Thread myThread6 = new Thread("T6"){
            @Override
            public void run() {
                m.sell(9.50);
            }
        };

        

        myThread1.start();
        myThread2.start();
        myThread3.start();
        myThread4.start();
        myThread5.start();
        myThread6.start();
    }

}