package cn.com.sxia;

public interface InvariantState {

}

package cn.com.sxia;

public class InvariantOK implements InvariantState {

}

package cn.com.sxia;

public class InvariantFailure implements InvariantState {public Object value;

public InvariantFailure(Object value)    {this.value = value;    }}

package cn.com.sxia;

public interface Invariant {    InvariantState invariant();}

package cn.com.sxia;

import java.util.Timer;import java.util.TimerTask;

public class Timeout extends Timer {

public Timeout(int delay,final String msg){super(true);//设为true表明该线程是一个后台线程(Daemon)        schedule(new TimerTask() {

            @Overridepublic void run() {                System.out.println(msg);                System.exit(0);            }        }, delay);    }

}

    public class Timer extends Object一种工具，线程用其安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。 与每个 Timer 对象相对应的是单个后台线程，用于顺序地执行所有计时器任务。计时器任务应该迅速完成。如果完成某个计时器任务的时间太长，那么它会“独占”计时器的任务执行线程。因此，这就可能延迟后续任务的执行，而这些任务就可能“堆在一起”，并且在上述不友好的任务最终完成时才能够被快速连续地执行。 对 Timer 对象最后的引用完成后，并且 所有未处理的任务都已执行完成后，计时器的任务执行线程会正常终止（并且成为垃圾回收的对象）。但是这可能要很长时间后才发生。默认情况下，任务执行线程并不作为守护线程 来运行，所以它能够阻止应用程序终止。如果调用者想要快速终止计时器的任务执行线程，那么调用者应该调用计时器的 cancel 方法。 如果意外终止了计时器的任务执行线程，例如调用了它的 stop 方法，那么所有以后对该计时器安排任务的尝试都将导致 IllegalStateException，就好像调用了计时器的 cancel 方法一样。 此类是线程安全的：多个线程可以共享单个 Timer 对象而无需进行外部同步。 此类不 提供实时保证：它使用 Object.wait(long) 方法来安排任务。 实现注意事项：此类可扩展到大量同时安排的任务（存在数千个都没有问题）。在内部，它使用二进制堆来表示其任务队列，所以安排任务的开销是 O(log n)，其中 n 是同时安排的任务数。 实现注意事项：所有构造方法都启动计时器线程。

package cn.com.sxia;

public class InvariantWatcher extends Thread {

private Invariant invariant;

public InvariantWatcher(Invariant invariant){this.invariant = invariant;        setDaemon(true);        start();    }

public InvariantWatcher(Invariant invariant,final int timeout){this(invariant);new Timeout(timeout, "超时了....");    }

public void run(){while(true){            InvariantState state = invariant.invariant();if (state instanceof InvariantFailure){                System.out.println("Invariant violated: " + ((InvariantFailure)state).value);                System.exit(0);            }        }    }

}

package cn.com.sxia;

public class EvenGenerator implements Invariant {

private int i;

public void next(){        i++;        i++;    }

public int getValue(){return i;    }

    @Overridepublic InvariantState invariant() {int val = i;if (val % 2 == 0)return new InvariantOK();elsereturn new InvariantFailure(new Integer(val));    }

public static void main(String[] args){        EvenGenerator gen = new EvenGenerator();new InvariantWatcher(gen);while(true){            gen.next();        }    }

}

多个线程访问某一个资源，例如数据库的连接。假想在服务器上运行着若干个回答客户端请求的线程。这些线程需要连接到同一数据库，但任一时刻只能获得一定数目的数据库连接。你要怎样才能够有效地将这些固定数目的数据库连接分配给大量的线程？一种控制访问一组资源的方法（除了简单地上锁之外），就是使用众所周知的信号量计数 (counting semaphore)。Java多线程信号量计数将一组可获得资源的管理封装起来。信号量是在简单上锁的基础上实现的，相当于能令线程安全执行，并初始化为可用资源个数的计数器。例如我们可以将一个信号量初始化为可获得的数据库连接个数。一旦某个线程获得了Java多线程信号量，可获得的数据库连接数减一。线程消耗完资源并释放该资源时，计数器就会加一。当信号量控制的所有资源都已被占用时，若有线程试图访问此信号量，则会进入阻塞状态，直到有可用资源被释放。Java多线程信号量最常见的用法是解决“消费者－生产者问题”。当一个线程进行工作时，若另外一个线程访问同一共享变量，就可能产生此问题。消费者线程只能在生产者线程完成生产后才能够访问数据。使用信号量来解决这个问题，就需要创建一个初始化为零的信号量，从而让消费者线程访问此信号量时发生阻塞。每当完成单位工作时，生产者线程就会向该信号量发信号（释放资源）。

package cn.com.sxia;

public class Semaphore implements Invariant {

private volatile int semaphore = 0;

public void acquire(){        ++semaphore;    }

public boolean available(){return semaphore == 0;    }

public void release(){        --semaphore;    }

    @Overridepublic InvariantState invariant() {int val = semaphore;if (val == 0 || val == 1){return new InvariantOK();        }else{return new InvariantFailure(new Integer(val));        }    }

}

package cn.com.sxia;

public class SemaphoreTester extends Thread {

private volatile Semaphore semaphore;

public SemaphoreTester(Semaphore semaphore){this.semaphore = semaphore;        setDaemon(true);        start();    }

public void run(){while(true){if (semaphore.available()){                yield();                semaphore.acquire();                yield();                semaphore.release();                yield();            }        }    }

public static void main(String[] args) throws InterruptedException {        Semaphore semaphore = new Semaphore();new SemaphoreTester(semaphore);new SemaphoreTester(semaphore);new InvariantWatcher(semaphore).join();    }

}

Invariant violated: -1