private boolean stopRequest = false;
public synchronized void requestStop()
{
       stopRequest = true;




}

可替代形式为:

private volatile boolean stopRequest = false;
public void requestStop()
{
       stopRequest = true;




}

不过，我查了一下volatile的原始用法：
If a variable is declared volatile, then additional constraints apply to the operations of each thread. Let T be a thread and let V and W be volatile variables.

A use operation by T on V is permitted only if the previous operation by T on V was load, and a load operation by T on V is permitted only if the next operation by T on V is use. The use operation is said to be "associated" with the read operation that corresponds to the load.

A store operation by T on V is permitted only if the previous operation by T on V was assign, and an assign operation by T on V is permitted only if the next operation by T on V is store. The assign operation is said to be "associated" with the write operation that corresponds to the store.

Let action A be a use or assign by thread T on variable V, let action F be the load or store associated with A, and let action P be the read or write of V that corresponds to F. Similarly, let action B be a use or assign by thread T on variable W, let action G be the load or store associated with B, and let action Q be the read or write of W that corresponds to G. If A precedes B, then P must precede Q. (Less formally: operations on the master copies of volatile variables on behalf of a thread are performed by the main memory in exactly the order that the thread requested.)

大意是每次进入volatile变量相关的操作代码块时，都会load一遍它最新的改变（无论它的值有没有改变），这种特性特别适合于多线程的情形。

二、关于线程安全的Singleton模式
前段时间也面试过别人，如何实现线程安全的Singleton模式？当然方案可能不止一个。
如果不考虑线程安全，很多人大概会这样写：

private static SingletonClass _instance = null;
private SingletonClass() {}
public static SingletonClass getInstance()
{
     if (_instance == null) 
     {
         _instance = new SingletonClass();
         return _instance;
     }
     return _instance;
}

直接替换为：

private static SingletonClass _instance = null;
private SingletonClass() {}
public static synchronized SingletonClass getInstance()
{
     if (_instance == null) 
     {
         _instance = new SingletonClass();
         return _instance;
     }
     return _instance;
}

这样同步的效率是非常低的。须知每次调用getInsance都会要进行同步，对这个类进行加锁。须知：
总的说来，synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。
在进一步阐述之前，我们需要明确几点：
A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。
B．每个对象只有一个锁（lock）与之相关联。
C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
如果是static方法，那么锁定的将是产生这个方法所在的class，否则应该是锁定该方法所在的对象，这是两码事。

最后发现有两种解决方法，不用synchronized关键字，一样可以保证线程：
1. 直接在类初始化阶段进行实例化

private static SingletonClass _instance = new SingletonClass();
private SingletonClass() {}
public static SingletonClass getInstance()
{

     return _instance;
}

　它的缺点是只要加载了SingletonClass，则一定会执行new操作，但是如果用户想调用该类的一些其它static方法，不需要这个类的唯一对象，则new操作显得多余。其实这个方法与Scott Merys在effective c++里提出的在函数体里声明static A a; return &a是很类似的效果。
2. 延迟实例化至调用阶段。
这需要专门为new操作创建一个委托类，这是Joshua比较喜欢的一种方式：

class SingletonDelegate 
{
     static SingletonClass _instance = new SingletonClass();
}

再细查一下，有几篇文章倒是挺好的，一并列在这里：
http://www.artima.com/designtechniques/threadsafety.html
http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
http://discuss.techinterview.org/default.asp?design.4.352250.7