Critical Section Problems

　　Here I wish to show you some of my DIY demo programs demonstrating how Critical Section Problems can be solved by using Peterson's Algorithm, Spinlocks as well as Semaphores.

　　This is a demo program of Peterson's Algorithm. Here two clients send messages to their corresponding server threads, and the two server threads print messages on the same terminal without interference.

import java.util.concurrent.atomic.*;
import java.util.*;
import java.io.*;

class Server {
    /**
     *  This class simulates a Server System that can
     *         service two Client Threads simultaneously
     */
    private class Task extends Thread {
        /**
         *  This class simulates a Server Thread
         */
        private int id, cnt;
        private Scanner in;
        
        public Task(int id,PipedOutputStream pout) throws IOException {
            this.id = id;
            in = new Scanner(new PipedInputStream(pout));
        }
        public void run() {
            /* Print the messages from the client */
            try {
               while (!getAndPrintMsg());
           } catch (Exception e) {
                System.err.println("Error 2: "+e);
            }
        }
        private boolean getAndPrintMsg() throws IOException {
            /* 
             * Implementation of Peterson's Algorithm:
             */
            String str = in.nextLine();
            if (!str.equals("over")) {
                flag[id].set(true);
                turn.set(1-id);
                while (flag[1-id].get()&&turn.get()==1-id);
                System.out.println("	"+this+" #"+(++cnt)+": 	"+str);    // critical section
                flag[id].set(false);
                return false;
            } else {
                return true;
            }
        }
        public String toString() {
            return "Server " + (id+1);
        }
    }
    
    private AtomicBoolean[] flag;
    private AtomicInteger turn;
    
    public Server(PipedOutputStream pout1,PipedOutputStream pout2) {
        // initialization of flag and turn
        flag = new AtomicBoolean[2];
        for (int i=0;i<2;i++) {
            flag[i] = new AtomicBoolean(false);
        }
        turn = new AtomicInteger(0);
        try {
            (new Task(0,pout1)).start();
            (new Task(1,pout2)).start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class Client extends Thread {
    /**
     *  This Class simulates a Client Thread
     */
    private int id;
    private PipedOutputStream pout;
    
    public Client(int id,PipedOutputStream pout) {
        this.id = id;
        this.pout = pout;
        start();
    }
    public void run() {
        try {
            for (int i=0;i<100;i++) {
                String str = this+" obtains the console
";
                pout.write(str.getBytes());
            }
            pout.write("over
".getBytes());
        } catch (Exception e) {
            System.err.println("Error 1: "+e);
        }
    }
    public String toString() {
        return "client "+(id+1);
    }
}

public class Main {
    
    public static void main(String[] args) {
        PipedOutputStream pout1 = new PipedOutputStream();
        PipedOutputStream pout2 = new PipedOutputStream();
        try {
            new Server(pout1, pout2);
            new Client(0,pout1);
            new Client(1,pout2);
        } catch (Exception e) {
            System.err.println("Error 0: "+e);
        }
    }
}

　　The following program implements Spinlock by using Java AtomicBoolean class:

import java.util.concurrent.atomic.*;

public class Main {
    /**
     *  This class implements Spinlock Algorithm
     */
    private static  class Task extends Thread {
        /**
         *  This class implements a task thread
         */
        private int idx;
        
        public Task(int idx) {
            this.idx = idx;
            start();
        }
        public void run() {
            LOOP:
            for (int i=1;i<=3;i++) {
                while (wait[idx].get()&&lock.getAndSet(true));
                System.out.println("	"+this+"  ("+i+")	in Critical Section");
                int next = idx;
                for (int j=1;j<NUM;j++) {
                    next = (next+1)%NUM;
                    if (wait[next].get()) {
                        wait[next].set(false);
                        continue LOOP;
                    }
                }
                lock.set(false);
            }
        }
        public String toString() {
            return "Task "+(idx+1);
        }
    }
    
    private static final int NUM = 50;
    private static AtomicBoolean lock;
    private static AtomicBoolean[] wait;
    
    public static void main(String[] args) {
        lock = new AtomicBoolean(false);
        wait = new AtomicBoolean[NUM];
        for (int i=0;i<NUM;i++) {
            wait[i] = new AtomicBoolean(false);
        }
        Task[] task = new Task[NUM];
        for (int i=0;i<NUM;i++) {
            task[i] = new Task(i);
        }
        for (int i=0;i<NUM;i++) {
            try {
                task[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

　　As the first demo of Java Semaphores, the following program solves the classical Sleeping Barber Problem.

import java.util.concurrent.atomic.*;
import java.util.concurrent.*;
import java.util.*;

public class Main {
    /**
     * This class simulates Sleeping Barber Problem
     */
    private static class Barber extends Thread{
        /**
         *  This class simulates a barber
         */
        
        public Barber() {
            start();
        }
        public void run() {
           try {
              while(num.get()>0) {
                   task.acquire();
                   service.release();
                   TimeUnit.MILLISECONDS.sleep(servTime);
               }
           } catch (Exception e) {
               e.printStackTrace();
           }
        }
    }
    private static class Customer extends Thread{
        /**
         *  This class simulates a customer
         */
        private int idx;
        
        public Customer(int idx) {
            this.idx = idx;
            start();
        }
        public void run() {
            try {
                mutex.acquire();
                if (chair>0) {
                    chair--;
                    mutex.release();
                } else {
                    synchronized(this) {
                        System.out.println("	"+this+" leaves");
                    }
                    mutex.release();
                    num.getAndDecrement();
                    return;
                }
                synchronized(this) {
                    System.out.println("	"+this+" sits and waits");
                }
                task.release();
                service.acquire();
                num.getAndDecrement();
                synchronized(this) {
                    System.out.println("	"+this+" is served");
                }
                TimeUnit.MILLISECONDS.sleep(servTime);
                mutex.acquire();
                chair++;
                mutex.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        public String toString() {
            return "Customer  # "+idx+"	";
        }
    }
    
    private static Semaphore mutex;
    private static int chair = 10;
    private static AtomicInteger num;
    private static Semaphore task;
    private static Semaphore service;
    private static int servTime = 25;
    private static int custTime = 20;
    
    public static void main(String[] argds) {
        mutex = new Semaphore(1);
        task = new Semaphore(0);
        service = new Semaphore(0);
        num = new AtomicInteger(50);
        System.out.println("Number of Chairs:	"+chair);
        System.out.println("Number of Customers:	"+num);
        System.out.println();
        int numVal = num.get();
        Barber barber = new Barber();
        Customer[] cust = new Customer[numVal];
        try {
             for (int i=0;i<numVal;i++) {
                 cust[i] = new Customer(i);
                 int t = (new Random()).nextInt(custTime);
                 TimeUnit.MILLISECONDS.sleep(t);
             }
             barber.join();
             for (int i=0;i<numVal;i++) {
                 cust[i].join();
             }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

　　The second example simulates Smoking Lounge Problem, where a smoker cannot smoke when a non-smoker stays in the lounge, and a non-smoker will not enter the lounge as long as there is a smoker smoking in the lounge.

import java.util.concurrent.atomic.*;
import java.util.concurrent.*;
import java.util.*;

public class Main {
    /**
     *  This class simulates Lounge Problem
     */
    private static class Smoker extends Thread{
        /**
         *  This class simulates a smoker
         */
        private int idx;
        
        public Smoker(int idx) {
            this.idx = idx;
            start();
        }
        public void run() {
            try {
                System.out.println("	"+this+" comes in");
                wait.acquire();
                if (smkCnt.getAndIncrement()==0) {
                    semp.acquire();
                }
                wait.release();
                System.out.println("	"+this+" smokes");
                int t = (new Random()).nextInt(10);
                TimeUnit.MILLISECONDS.sleep(t);
                System.out.println("	"+this+" goes out");
                if (smkCnt.decrementAndGet()==0) {
                    semp.release();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        public String toString() {
            return "Smoker # "+idx+" ";
        }
    }
    private static class Nonsmk extends Thread {
        /**
         * This class simulates a non-smoker
         */
        private int idx;
        
        public Nonsmk(int idx) {
            this.idx = idx;
            start();
        }
        public void run() {
            try {
                wait.acquire();
                if (nonCnt.getAndIncrement()==0) {
                    semp.acquire();
                }
                wait.release();
                System.out.println("	"+this+" comes in");
                int t = (new Random()).nextInt(10);
                TimeUnit.MILLISECONDS.sleep(t);
                System.out.println("	"+this+" goes out");
                if (nonCnt.decrementAndGet()==0) {
                    semp.release();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        public String toString() {
            return "NonSmk  # "+idx+" ";
        }
    }
    
    private static final int num = 100;
    private static Semaphore wait;
    private static Semaphore semp;
    private static AtomicInteger smkCnt;
    private static AtomicInteger nonCnt;
    
    static {
        wait = new Semaphore(1);
        semp = new Semaphore(1);
        smkCnt = new AtomicInteger(0);
        nonCnt = new AtomicInteger(0);
    }
    public static void main(String[] args) {
        int smkNum=0, nonNum=0;
        Thread[] thread = new Thread[num];
        try {
            for (int i=0;i<num;i++) {
                int r = (new Random()).nextInt(5);
                if (r<3) {
                    thread[i] = new Nonsmk(nonNum++);
                } else {
                    thread[i] = new Smoker(smkNum++);
                }
                int t = (new Random()).nextInt(5);
                TimeUnit.MILLISECONDS.sleep(t);
            }
            for (int i=0;i<num;i++) {
                thread[i].join();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

　　At the end of this article, I wish to generalize the smoking lounge problem above: given num different types of threads, as well as all pairs of i and j such that thread type i and type j cannot get access to the critical section together (possibly i==j), describe the behavior of each type of thread so that all of them can work orderly without deadlock or starvation.

　　The input of the program should comprise: (1) one integer num indicating the number of thread types; (2) num integers indicating the number of each type of threads; (3) one integer N indicating the number of following input pairs; (4) N integer pairs representing the thread types that cannot coexist in the critical section.

　　As a matter of fact, this problem is a generalization of many classical problems such as Reader-Writer Problem, Baboon Crossing Problem, and Search/Insert/Delete Problem. For example, we assume there are 100 threads to search, 50 threads to insert and 20 threads to delete, then the input should be:

100
20
0 2
1
2
2

　　The following program is a naive general solution that I have come up with:

import java.util.concurrent.atomic.*;
import java.util.concurrent.*;
import java.util.*;
import java.io.*;

class Input {
    private Scanner in;
    private StringTokenizer tok;
    
    public Input() {
        in = new Scanner(new BufferedInputStream(System.in));
    }
    public String nextString() {
        while  (tok==null||!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.nextLine());
        } 
        return tok.nextToken();
    }
    public int nextInt() {
        while  (tok==null||!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.nextLine());
        } 
        return Integer.parseInt(tok.nextToken());
    }
    public double nextDouble() {
        while  (tok==null||!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.nextLine());
        } 
        return Double.parseDouble(tok.nextToken());
    }
    public void close() {
        in.close();
    }
}

class CSP {
    private class Task extends Thread {
        private int type;
        
        public Task(int type) {
            this.type = type;
        }
        public void run() {
            try {
                sempAcquire();
                System.out.println("	"+this+" is working.");
                sempRelease();
            } catch (Exception e) {
                System.err.println("TASK RUN Error: "+e);
            }
        }
        private void sempAcquire() throws InterruptedException {
            wait.acquire();
            if (mutex[type][type]) {
                semp[type][type].acquire();
            }
            if (cnt[type].getAndIncrement()==0){
                for (int i=0;i<type;i++) {
                    if (mutex[type][i]) {
                        semp[type][i].acquire();
                    }
                }
                for (int i=type+1;i<num;i++) {
                    if (mutex[i][type]) {
                        semp[i][type].acquire();
                    }
                }
            }
            wait.release();
        }
        private void sempRelease() {
            if (cnt[type].getAndDecrement()==1){
                for (int i=num-1;i>type;i--) {
                    if (mutex[i][type]) {
                        semp[i][type].release();
                    }
                }
                for (int i=type-1;i>=0;i--) {
                    if (mutex[type][i]) {
                        semp[type][i].release();
                    }
                }
            }
            if (mutex[type][type]) {
                semp[type][type].release();
            }
        }
        public String toString() {
            int idxVal = idx[type].getAndIncrement();
            return "Task "+type+" #"+idxVal;
        }
    }
    
    private int num;
    private Task[][] taskArr;
    private AtomicInteger[] cnt;
    private AtomicInteger[] idx;
    private Semaphore wait;
    private Semaphore[][] semp;
    private boolean mutex[][];
    
    public CSP(int num) {
        this.num = num;
        taskArr = new Task[num][];
        cnt = new AtomicInteger[num];
        idx = new AtomicInteger[num];
        for (int i=0;i<num;i++) {
            cnt[i] = new AtomicInteger(0);
            idx[i] = new AtomicInteger(0);
        }
        try {
            wait = new Semaphore(1);
            semp = new Semaphore[num][];
            mutex = new boolean[num][];
            for (int i=0;i<num;i++) {
                semp[i] = new Semaphore[i+1];
                mutex[i] = new boolean[i+1];
            }
        } catch (Exception e) {
            System.err.println("CSP INIT Error: "+e);
        }
    }
    public void genThread(int type,int n) {
        taskArr[type] = new Task[n];
        for (int i=0;i<n;i++) {
            taskArr[type][i] = new Task(type);
        }
    }
    public void setMutex(int i,int j) {
        if (j>i) {
            i += j;
            j = i-j;
            i -= j;
        }
        mutex[i][j] = true;
        try {
            semp[i][j] = new Semaphore(1);
        } catch (Exception e) {
            System.err.println("CSP SETMUTEX Error: "+e);
        }
    }
    public void start() {
        class Pair {
            public int type,idx;
            public Pair(int i,int j) {
                type = i;
                idx = j;
            }
        }
        List<Pair> q = new LinkedList<Pair>();
        for (int i=0;i<num;i++) {
            for (int j=0;j<taskArr[i].length;j++) {
                q.add(new Pair(i,j));
            }
        }
        Collections.shuffle(q,new Random());
        while (!q.isEmpty()) {
            Pair item = q.remove(0);
            taskArr[item.type][item.idx].start();
        }
    }
    public void join() {
        try {
            for (int i=0;i<num;i++) {
                for (int j=0;j<taskArr[i].length;j++) {
                    taskArr[i][j].join();
                }
            }
        } catch (Exception e) {
            System.err.println("CSP JOIN Error: "+e);
        }
    }
}


public class Main {
    
    public static void main(String[] args) {
        Input in = new Input();
        int n = in.nextInt();
        CSP csp = new CSP(n);
        for (int i=0;i<n;i++) {
            csp.genThread(i,in.nextInt());
        }
        int m = in.nextInt();
        for (int i=0;i<m;i++) {
            csp.setMutex(in.nextInt(),in.nextInt());
        }
        in.close();
        System.out.println("Critical Section Problem:");
        csp.start();
        csp.join();
    }
}

 

References:

　　1. Nutt, Gary. Operating Systems: A Modern Perspective[M].北京：机械工业出版社， 2004-02

　　2. Eckel, Bruce. Thinking in Java[M]. 北京：机械工业出版社， 2007-06