Zaphod42 fucked around with this message at 00:49 on Nov 17, 2016

Volguus fucked around with this message at 02:46 on Nov 17, 2016

StringBuilder sb = new StringBuilder();
inventory.forEach(i -> sb.append(i.getShortDescription()));
output = sb.toString();

output = inventory.stream()
.map(Inventory::getShortDescription)
.collect(Collectors.joining())

pigdog fucked around with this message at 17:40 on Nov 23, 2016

• turn the collection into a data stream
  
• for each element, output the result of getShortDescription
  
• reduce all those to a single result using String.concat
  

baka kaba fucked around with this message at 11:44 on Nov 23, 2016

public class Locker {

    private static final HashMap<Long, Semaphore> semaphores = new HashMap<Long, Semaphore>();

    public synchronized static Semaphore getMutex(Long ydId) {
        System.out.println("Trying to lock " + ydId);
        if (!semaphores.containsKey(ydId)) semaphores.put(ydId, new Semaphore(ydId));
        return  semaphores.get(ydId);
    }

    public synchronized static void removeMutex(Long ydId) {
        System.out.println("Removing lock " + ydId);
        Semaphore semaphore = semaphores.get(ydId);
        if (semaphore != null) {
            semaphore.decrement();
            if (semaphore.getCount() <= 0) {
                //System.out.println("Unused lock removed " + ydId);
                semaphores.remove(ydId);
            }
        }
    }
}

public class MutexTestThread implements Runnable {

    private int id;
    Long ydId = 1L;

    public MutexTestThread(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        synchronized (Locker.getMutex(ydId)) {
            Locker.getMutex(ydId).increment();
            TestFunction();
            Locker.removeMutex(ydId);
        }
    }

    public void TestFunction() {
        Main.errorCounter = Main.errorCounter + 1;
        try {
            Thread.sleep(Math.max(0, 100 - (id * 20)));
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            Main.errorCounter = Main.errorCounter - 1;
            if (Main.errorCounter != 0) System.out.println("Main.errorCounter: " + Main.errorCounter);
        }
    }
}

Boz0r fucked around with this message at 10:32 on Dec 2, 2016

Main.errorCounter = Main.errorCounter + 1;

Main.errorCounter = Main.errorCounter - 1;

Thread 1    read (5)      add (5+1)      write(6)

Thread 2                   read (5)        add (5+1)    write (6)

baka kaba fucked around with this message at 13:02 on Dec 2, 2016

public class Main {

    static int numYdelser = 3;
    static int numThreads = 8;

    static ConcurrentHashMap<Integer, Integer> errorCounters;

    public static void main(String[] args) throws InterruptedException {

        errorCounters = new ConcurrentHashMap<Integer, Integer>();

        for (int i = 0; i < numThreads; i++) {
            (new Thread(new TestThread(i))).start();
            Thread.sleep(Math.max(0, 100 - (i * 20)));
        }

        Thread.sleep(5000);

        log("Locker size: " + Locker.getInstance().size() + "\n" + Main.errorCounters.values());
    }

    static void increment(int i) {
        synchronized (errorCounters) {
            errorCounters.putIfAbsent(i, 0);
            errorCounters.put(i, errorCounters.get(i) + 1);
        }
    }

    static void decrement(int i) {
        synchronized (errorCounters) {
            errorCounters.putIfAbsent(i, 0);
            errorCounters.put(i, errorCounters.get(i) - 1);
        }
    }

    static int getCount(int i) {
        synchronized (errorCounters) {
            return errorCounters.get(i);
        }
    }

    public static void log(String s) {
        System.out.println(Thread.currentThread().getId() + "\t" + s);
    }
}

public class Locker {

    private static Locker instance;

    private ConcurrentHashMap<Integer, Semaphore> semaphores;

    public static synchronized Locker getInstance() {
        if (instance == null) {
            synchronized (Locker.class) {
                if (instance == null) {
                    instance = new Locker();
                }
            }
        }
        return instance;
    }

    public Locker() {
        this.semaphores = new ConcurrentHashMap<Integer, Semaphore>();
    }

    public synchronized Semaphore get(int ydId) {
        semaphores.putIfAbsent(ydId, new Semaphore(ydId));
        semaphores.get(ydId).increment();
        return semaphores.get(ydId);
    }

    public synchronized void remove(int ydId) {
        Semaphore semaphore = semaphores.get(ydId);
        if (semaphore != null) {
            semaphore.decrement();
            if (semaphore.getCount() <= 0) {
                semaphores.remove(ydId);
            }
        }
    }

    private class Semaphore { 
        ...
    }
}

public class TestThread implements Runnable {

    private int id;
    private int ydId;

    public TestThread(int id) {
        this.id = id;
        ydId = id % Main.numYdelser;
    }

    @Override
    public void run() {
        Main.log("Trying to lock " + ydId);
        synchronized (Locker.getInstance().get(ydId)) {
            Main.log(ydId + " LOCKED >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
            TestFunction();
            Locker.getInstance().remove(ydId);
            Main.log(ydId + " UNLOCKED <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
        }
    }

    public void TestFunction() {
        int error = 0;
        Main.increment(ydId);
        try {
            Main.log(ydId + " Going to sleep");
            Thread.sleep(Math.max(0, 100 - (id * 20)));
            Main.log(ydId + " Waking up");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            Main.decrement(ydId);
            if (Main.getCount(ydId) != error) {
                Main.log("OH poo poo OH poo poo OH poo poo OH poo poo OH poo poo OH poo poo OH poo poo OH poo poo OH poo poo");
                Main.log("poo poo hosed UP!!!: " + Main.getCount(ydId) + " should be " + error);
                Main.log("OH poo poo OH poo poo OH poo poo OH poo poo OH poo poo OH poo poo OH poo poo OH poo poo OH poo poo");
            }
        }
    }
}

Boz0r fucked around with this message at 10:32 on Dec 5, 2016

Boz0r fucked around with this message at 10:33 on Dec 5, 2016

Boz0r fucked around with this message at 11:05 on Dec 5, 2016

Paul MaudDib fucked around with this message at 01:24 on Dec 6, 2016