Thinking In Java 之 多线程 4

Deadlock

Deadlock can occur if four conditions are simultaneously met:
1. Mutual exclusion. At least one resource used by the tasks must not be shareable.
2. At least one task must be holding a resource and waiting to acquire a resource currently held by another task.
3. A resource cannot be preemptively taken away from a task. Tasks only release resources as a normal event.
4. A circular wait can happen, whereby a task waits on a resource held by another task, which in turn is waiting on a resource held by another task, and so on, until one of the tasks is waiting on a resource held by the first task, thus grid-locking everything.

public class Chopstick {
    private boolean taken = false;
    public synchronized void take() throws InterruptedException {
        while(taken) {
            wait();
        }
        taken = true;
    }

    public synchronized void drop() {
        taken = false;
        notifyAll();
    }
}

public class Philosopher implements Runnable{
    private Chopstick left;
    private Chopstick right;
    private final int id;

    private void pause() throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(500);
    }

    public Philosopher(Chopstick left, Chopstick right, int ident) {
        this.left = left;
        this.right = right;
        id = ident;
    }

    @Override
    public void run() {
        try {
            while(!Thread.interrupted()) {
                System.out.println(this + " " + "thinking");
                pause();
                System.out.println(this + " " + "grabbing right");
                right.take();
                System.out.println(this + " " + "grabbing left");
                left.take();
                System.out.println(this + " " + "eating");
                pause();
                right.drop();
                left.drop();
            }
        } catch (InterruptedException e) {
            System.out.println(this + " " + "exiting via interrupt");
        }
    }

    public String toString() {
        return "Philosopher" + id;
    }

}

死锁：

public class DeadLockingDiningPhilosophers {
    public static void main(String[] args) throws IOException {
        int size = 5;
        ExecutorService exec = Executors.newCachedThreadPool();
        Chopstick[] sticks = new Chopstick[size];
        for(int i=0;i<size;i++) {
            sticks[i] = new Chopstick();
        }
        for(int i=0;i<size;i++) {
            exec.execute(new Philosopher(sticks[i], sticks[(i+1) % size], i));
        }
        System.out.println("Press 'Enter' to quit");
        System.in.read();
        exec.shutdownNow();
    }
}

解除死锁：

public class FixedDiningPhilosophers {
    public static void main(String[] args) throws IOException {
        int size = 5;
        ExecutorService exec = Executors.newCachedThreadPool();
        Chopstick[] sticks = new Chopstick[size];
        for(int i=0;i<size;i++) {
            sticks[i] = new Chopstick();
        }
        for(int i=0;i<size;i++) {
            if(i<(size-1)) {
                exec.execute(new Philosopher(sticks[i], sticks[i+1], i));
            }else {
                exec.execute(new Philosopher(sticks[0], sticks[i],i));
            }
        }
        System.out.println("Press 'Enter' to quit");
        System.in.read();
        exec.shutdownNow();
    }
}

CountDownLatch

You give an initial count to a CountDownLatch object, and you task that calls await() on that object will block until the count reaches zero. Other tasks may call countDown() on the object to reduce the count, presumably when a task finished its job. A CountDownLatch is designed to be used in a one-shot fashion; the count cannot be reset. If you need a version that resets the count, you can use a CyclicBarrier instead.

class TaskPortion implements Runnable {

    private static int counter = 0;
    private final int id = counter++;
    private static Random rand = new Random(47);
    private final CountDownLatch latch;

    public TaskPortion(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        try {
            doWork();
            latch.countDown();
        } catch (InterruptedException e) {
            // Acceptable way to exit
        }
    }

    private void doWork() throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(rand.nextInt(2000));
        System.out.println(this + "completed");
    }

    public String toString() {
        return String.format("%1$-3d", id);
    }

}

// Waits on the CountDownLatch
class WaitingTask implements Runnable{

    private static int counter = 0;
    private final int id = counter++;
    private final CountDownLatch latch;

    WaitingTask(CountDownLatch latch){
        this.latch = latch;
    }

    @Override
    public void run() {
        try {
            latch.await();
            System.out.println("Latch barrier passed for " + this);
        } catch (InterruptedException e) {
            System.out.println(this + " interrupted");
        }
    }

    public String toString() {
        return String.format("WaitingTask %1$-3d ", id);
    }

}

public class CountDownLatchDemo {
    static final int SIZE = 100;
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        // All must share a single CountDownLatch object:
        CountDownLatch latch = new CountDownLatch(10);
        for(int i=0;i<10;i++) {
            exec.execute(new WaitingTask(latch));
        }
        for(int i=0;i<SIZE;i++) {
            exec.execute(new TaskPortion(latch));
        }
        System.out.println("Launched all tasks");
        exec.shutdown();// Quit when all tasks complete
    }
}

CyclicBarrier

A CyclicBarrier is used in situations where you want to create a group of tasks to perform work in parallel, and then wait they are all finished before moving on to the next step(something like join(), it would seem).

class Horse implements Runnable {

    private static int counter = 0;
    private final int id = counter++;
    private int strides = 0;
    private Random rand = new Random();
    private static CyclicBarrier barrier;

    public Horse(CyclicBarrier b) {
        barrier = b;
    }

    public synchronized int getStrides() {
        return strides;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                synchronized (this) {
                    strides += rand.nextInt(3);
                }
                barrier.await();
            }
        } catch (InterruptedException e) {
            // A legitimate way to exit
        } catch (BrokenBarrierException e) {
            // This one we want to know about
            throw new RuntimeException(e);
        }
    }

    public String toString() {
        return "Horse " + id + " ";
    }

    public String tracks() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < getStrides(); i++) {
            sb.append("*");
        }
        sb.append(id);
        return sb.toString();
    }

}

public class HorseRace {
    static final int FINISH_LINE = 75;
    private List<Horse> horses = new ArrayList<Horse>();
    private ExecutorService exec = Executors.newCachedThreadPool();
    private CyclicBarrier barrier;

    public HorseRace(int nHorses, final int pause) {
        barrier = new CyclicBarrier(nHorses, new Runnable() {

            @Override
            public void run() {
                StringBuilder s = new StringBuilder();
                for (int i = 0; i < FINISH_LINE; i++) {
                    s.append("="); // The fence on the racetrack
                }
                System.out.println(s);
                for (Horse horse : horses) {
                    System.out.println(horse.tracks());
                }
                for (Horse horse : horses) {
                    if (horse.getStrides() >= FINISH_LINE) {
                        System.out.println(horse + "won!");
                        exec.shutdownNow();
                        return;
                    }
                }
                try {
                    TimeUnit.MILLISECONDS.sleep(pause);
                } catch (InterruptedException e) {
                    System.out.println("barrier-action sleep interrupted");
                }
            }

        });

        for(int i=0;i<nHorses;i++) {
            Horse horse = new Horse(barrier);
            horses.add(horse);
            exec.execute(horse);
        }

    }

    public static void main(String[] args) {
        new HorseRace(7,200);
    }
}

A CyclicBarrier can be given a “barrier action,” which is a Runnable that is automatically executed when the count reaches zero.
Once all the tasks have passed the barrier, it is automatically ready for the next round.