重点考虑线程安全的地方有哪些？

第一点：无状态的对象一定是线程安全的

那么是是无状态的对象呢？这里需要延生出很多的java相关的概念和问题，要理解什么是有状态的对象，什么是无状态的对象。

这一点我们可以从servlet中看到这个结论，java的servlet不论是各种的mvc框架还是java中纯servlet我们可以看到他们大部分是线程安全的，因为这些对象的信息封装在方法的内部，作为类的属性的变量是很少存在的，也就是不包含任何域的时候也不引用其他对象的域的时候。这个时候这些变量是作为线程内的局部变量而存在的时候就不需要考虑线程安全的问题。

1，有状态就是有数据存储功能。有状态对象(Stateful Bean)，就是有实例变量的对象 ，可以保存数据，是非线程安全的。在不同方法调用间不保留任何状态。无状态就是一次操作，不能保存数据。

2，无状态对象(Stateless Bean)，就是没有实例变量的对象 .不能保存数据，是不变类，是线程安全的。

现在举例子进行说明：

StatefulBean是一个有状态的对象

public class StatefulBean {  
  
    public int state;  
    // 由于多线程环境下，user是引用对象，是非线程安全的  
    public User user;  
  
    public int getState() {  
        return state;  
    }  
  
    public void setState(int state) {  
        this.state = state;  
    }  
  
    public User getUser() {  
        return user;  
    }  
  
    public void setUser(User user) {  
        this.user = user;  
    }  
}  

我们知道在java中像Dao这样的类是没有可变属性的没有状态信息的

public class StatelessBeanService {  
  
    // 虽然有billDao属性，但billDao是没有状态信息的，是Stateless Bean.  
    BillDao billDao;  
  
    public BillDao getBillDao() {  
        return billDao;  
    }  
  
    public void setBillDao(BillDao billDao) {  
        this.billDao = billDao;  
    }  
  
    public List<User> findUser(String Id) {  
return null;  
    }  
}  
一个类的内部状态创建后，在整个生命期间都不会发生变化时，就是不变类。这种使用不变类的做法叫做不变模式。
不变模式有两种形式：一种是弱不变模式，另一种是强不变模式。
弱不变模式：
一个类的实例的状态是不可变化的，但是这个类的引用的实例具有可能会变化的状态。这样的类符合弱不变模式的定义。要实现弱不变模式，一个类必须满足如下条件：

    第一，对象没有任何方法会修改对象的状态，当对象的构造函数对对象的状态初始化之后，对象的状态便不再改变。

    第二，所有的属性都应当是私有的，以防客户端对象直接修改任何的内部状态。

    第三，这个对象所引用的对象如果是可变对象的话，必须设法限制外界对这个对象的访问，以防止对这些对象的修改。如果可能应该尽量在不变对象的内部来初始化。

    弱不变模式的缺点是：
一个弱不变对象引用的实例变量可以是可变对象，可能会通过外界修改父对象的状态，这是一个显著的缺点。可以在初始化可变对象时，先进行clone。

代码实例：

public class WeakImmutable {  
  
    // 属性私有，满足条件2  
    private int state;  
    // 属性私有，满足条件2  
    private User user;  
  
    private Integer age;  
  
    public WeakImmutable(int state, User user, Integer age) {  
        this.state = state;  
        this.user = user;  
        this.age = age;  
    }  
  
    public int getState() {  
        return this.state;  
    }  
  
    public User getUser() {  
        return this.user;  
    }  
  
    public Integer getAge() {  
        return this.age;  
    }  
  
    public void setState() {  
        // 对象没有任何方法修改对象的状态,满足条件1  
        // do nothing.  
    }  
  
    public static void main(String[] args) {  
        int state = 0;  
        User u = new User();  
        Integer age = 100;  
        u.setName("yes");  
        WeakImmutable weak = new WeakImmutable(state, u, age);  
        System.out.println("原始值：" + weak.getState() + ","  
                + weak.getUser().getName() + "," + weak.getAge());  
        // 修改引用后  
        state = 5;  
        // User由于是可变对象引用，所以有影响  
        u.setName("no");  
        age = 200;  
        System.out.println("修改引用后：" + weak.getState() + ","  
                + weak.getUser().getName() + "," + weak.getAge());  
    }  
} 
强不变模式：
    一个类的实例的状态不会改变，同时它的子类的实例也具有不可变化的状态。这样的类符合强不变模式。要实现强不变模式，一个类必须首先满足弱不变模式所要求的所有条件，并且还要满足下面条件之一：
    第一，所考虑的类所有的方法都应当是final，这样这个类的子类不能够置换掉此类的方法。
    第二，这个类本身就是final的，那么这个类就不可能会有子类，从而也就不可能有被子类修改的问题。 
比如常见的String类等都是不可变类

优缺点：
不变模式可增强对象的健壮性。不变模式允许多个对象共享某一对象，降低了对该对象进行并发访问时的同步化开销。
唯一缺点是一旦需要修改一个不变对象的状态，就只好创建一个新的同类对象，在需要频繁修改不变对象的环境里，
会有大量的不变对象作为中间结果被创建出来，再被Java的垃圾收集器收走，这是一种资源的浪费。

总结：
不变模式的核心就是对象不变，从而引伸出对象复用共享的思想。如无状态的单例模式，
享元(Flyweight)模式及原型模式(Prototype)都可以认为是不变模式的应用。
其它如线程池，缓存等的实现也一定程度上是使用不变模式。
Spring对Service层、Dao层bean的默认单例实现，我认为都是沿用了不变模式中共享的思想。

单例模式中的有状态和无状态:
单例类可以是有状态的（stateful），一个有状态的单例对象一般也是可变（mutable）单例对象。有状态的可变的单例对象常常当做状态库（repositary）使用。
比如一个单例对象TaskCache（Spring中配为singleton）可以持有一个AtomicLong类型的属性，用来给一个系统提供一个数值惟一的序列号码，作为任务通迅管理的ID生成器。
同时，一个单例类也可以持有一个聚集，从而允许存储多个状态，如示例中的ExpiringMap缓存任务列表。

public class TaskCache {  
  
    // 请求超时  
    private short requestTimeout;  
  
    // 这个缓存Map是线程安全,并且有定时超时功能  
    private ExpiringMap<String, Object> tasksMap = new ExpiringMap<String, Object>();  
  
    // 线程安全的原子类,示例有状态的单例类  
    private static AtomicLong seqNo = new AtomicLong(1);  
  
    // 示例有状态的单例类  
    public Long nextSeqNo() {  
        return seqNo.getAndIncrement();  
    }  
  
    public void setRequestTimeout(short requestTimeout) {  
        this.requestTimeout = requestTimeout;  
    }  
  
    // 启动过期检测  
    public void startExpiring() {  
        tasksMap.getExpirer().setTimeToLive(requestTimeout);  
        tasksMap.getExpirer().startExpiringIfNotStarted();  
    }  
  
    // 停止过期检测  
    public void stopExpiring() {  
        tasksMap.getExpirer().stopExpiring();  
    }  
  
    // 取任务列表.  
    public Object getTasks(String key) {  
        return tasksMap.get(key);  
    }  
  
    // 去除任务列表.  
    public Object removeTasks(String key) {  
        return tasksMap.remove(key);  
    }  
  
    // 添加任务列表.  
    public void addTasks(String key, Object value) {  
        tasksMap.put(key, value);  
    }  
}  
Spring中的有状态(Stateful)和无状态(Stateless)

1.通过上面的分析，相信大家已经对有状态和无状态有了一定的理解。无状态的Bean适合用不变模式，技术就是单例模式，这样可以共享实例，提高性能。有状态的Bean，多线程环境下不安全，那么适合用Prototype原型模式。Prototype: 每次对bean的请求都会创建一个新的bean实例。
2.默认情况下，从Spring bean工厂所取得的实例为singleton（scope属性为singleton）,容器只存在一个共享的bean实例。
3.理解了两者的关系，那么scope选择的原则就很容易了：有状态的bean都使用prototype作用域，而对无状态的bean则应该使用singleton作用域。
4.如Service层、Dao层用默认singleton就行，虽然Service类也有dao这样的属性，但dao这些类都是没有状态信息的，也就是相当于不变(immutable)类，所以不影响。Struts2中的Action因为会有User、BizEntity这样的实例对象，是有状态信息的，在多线程环境下是不安全的，所以Struts2默认的实现是Prototype模式。在Spring中，Struts2的Action中，scope要配成prototype作用域。
Servlet、Struts中的有状态和无状态:
1.Servlet体系结构是建立在Java多线程机制之上的，它的生命周期是由Web 容器负责的。一个Servlet类在Application中只有一个实例存在，也就是有多个线程在使用这个实例。这是单例模式的应用。无状态的单例是线程安全的，但我们如果在Servlet里用了实例变量，那么就变成有状态了，是非线程安全的。如下面的用法就是不安全的,因为user,out都是有状态信息的。

总结：

Stateless无状态用单例Singleton模式，Stateful有状态就用原型Prototype模式。
Stateful 有状态是多线程编码的天敌，所以在开发中尽量用Stateless无状态，无状态是不变(immutable)模式的应用，有很多优点：不用管线程和同步的问题，如果值是不可变的，程序不用担心多个线程改变共享状态，所以可以避免线程竞争的bugs. 因为没有竞争，就不用用locks等机制，所以无状态的不变机制，也可以避免产生死锁现象。