在讨论String之前先看一下并发模式中的不变模式
Immutable设计模式
核心思想
一个对象一旦被创建， 它的内部状态永远不会发生改变， 因此我们在对他进行多线程操作的时候是不需要并发控制的， 因此在多线程环境下可以省略同步和锁等待的时间， 提高系统性能。 不变模式和只读属性并不是同一个东西， 对于只读属性而言只是保证了没有任何第三方线程去修改它的属性， 但是它本身还是有可能变化的， 不变模式要求， 对象创建之后， 其内部状态和数据会保持绝对稳定。
设计方式
- 去除setter方法
- 将所有属性设为私有并用final标注， 以确保不能修改
- 对class定义final确保没有子类可以通过重载修改它的行为。
- 有一个可以创建完整对象的构造函数。
String
常量池：
- 常量池简单定义：常量池在java用于保存在编译期已确定的，已编译的class文件中的一份数据。它包括了关于类，方法，接口等中的常量，也包括字符串常量，如String s = "java"这种申明方式。常量池是在堆内存中的一块。
简单来说就是两个String拥有相同的值时， 他们会复用常量池中的同一份拷贝， 但是如果是new一个String的话， 它还是会在堆里 - String str1 = new String("abc");
第一种是用new()来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。运行时期创建 - String str2 = "abc";
而第二种是先在栈中创建一个对String类的对象引用变量str2，然后通过符号引用去字符串常量池里找有没有"abc",如果没有，则将"abc"存放进字符串常量池，并令str2指向”abc”，如果已经有”abc” 则直接令str2指向“abc”。编译期间完成 - intern：
- 直接使用双引号声明出来的String对象会直接存储在常量池中。
- 如果不是用双引号声明的String对象，可以使用String提供的intern方法。intern 方法会从字符串常量池中查询当前字符串是否存在，若不存在就会将当前字符串放入常量池中
不变性：
- char数组
- offset 偏移
- count长度
JDK1.6中
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > count) {
throw new StringIndexOutOfBoundsException(endIndex);
}
if (beginIndex > endIndex) {
throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
}
return ((beginIndex == 0) && (endIndex == count)) ? this :
new String(offset + beginIndex, endIndex - beginIndex, value);
}
public String substring(int beginIndex, int endIndex) {
String(int offset, int count, char value[]) {
this.value = value;
this.offset = offset;
this.count = count;
}
subString其实是直接复用了数组， 改变了偏移量和长度而已，这样的话就不会真正销毁掉之前的数组， 在JDK1.7之后对此策略进行了改变：
public String(char value[], int offset, int count) {
if (offset < 0) {
throw new StringIndexOutOfBoundsException(offset);
}
if (count < 0) {
throw new StringIndexOutOfBoundsException(count);
}
// Note: offset or count might be near -1>>>1.
if (offset > value.length - count) {
throw new StringIndexOutOfBoundsException(offset + count);
}
this.value = Arrays.copyOfRange(value, offset, offset+count);
}
将String的构造函数改成了这样， 也就是根据偏移量等条件重新复制一份。显然这种方式速度会更慢， 所以褒贬不一。 更简单的解决方式其实应该是显示的new String（str.subString(begin, end)）， 这样就不会出现内存泄露的问题了。
StringBuilder
String每+一次都会重新复制数组， 为了解决String是不变模式的问题而设计了该类。
它有一个容量参数的概念， 可以根据要存储的大小预先设好， 一开始就初始化一个足够大的数组， 不然的话当数组容量超过时会需要扩容操作， 会用到Arrays.copyOf(value, newCapacity), 其中会有一些消耗， 该类是非线程安全的
StringBuffer
线程安全的
无状态和有状态
String的设计是采用了一种无状态的思路以保证并发。我们可以深入的了解一下这种设计思路
有状态
有状态就是有数据存储功能。有状态对象(Stateful Bean)，就是有实例变量的对象，可以保存数据，是非线程安全的。在不同方法调用间不保留任何状态。
1. /**
2. * 有状态bean,有state,user等属性，并且user有存偖功能，是可变的。
3. *
4. * @author Peter Wei
5. *
6. */
7. public class StatefulBean {
8.
9. public int state;
10. // 由于多线程环境下，user是引用对象，是非线程安全的
11. public User user;
12.
13. public int getState() {
14. return state;
15. }
16.
17. public void setState(int state) {
18. this.state = state;
19. }
20.
21. public User getUser() {
22. return user;
23. }
24.
25. public void setUser(User user) {
26. this.user = user;
27. }
28. }
无状态
无状态就是一次操作，不能保存数据。无状态对象(Stateless Bean)，就是没有实例变量的对象.不能保存数据，是不变类，是线程安全的。
单例模式中的有状态和无状态:
单例类可以是有状态的（stateful），一个有状态的单例对象一般也是可变（mutable）单例对象。有状态的可变的单例对象常常当做状态库（repositary）使用。比如一个单例对象TaskCache（Spring中配为singleton）可以持有一个AtomicLong类型的属性，用来给一个系统提供一个数值惟一的序列号码，作为任务通迅管理的ID生成器。同时，一个单例类也可以持有一个聚集，从而允许存储多个状态，如示例中的ExpiringMap缓存任务列表。
1. import java.util.concurrent.atomic.AtomicLong;
2.
3. import org.apache.mina.util.ExpiringMap;
4.
5. /**
6. * Description: 内存中缓存的实时控制端任务列表.示例有状态的单例类
7. *
8. * @author Peter Wei
9. * @version 1.0 Dec 2, 2008
10. */
11. public class TaskCache {
12.
13. // 请求超时
14. private short requestTimeout;
15.
16. // 这个缓存Map是线程安全,并且有定时超时功能
17. private ExpiringMap<String, Object> tasksMap = new ExpiringMap<String, Object>();
18.
19. // 线程安全的原子类,示例有状态的单例类
20. private static AtomicLong seqNo = new AtomicLong(1);
21.
22. // 示例有状态的单例类
23. public Long nextSeqNo() {
24. return seqNo.getAndIncrement();
25. }
26.
27. public void setRequestTimeout(short requestTimeout) {
28. this.requestTimeout = requestTimeout;
29. }
30.
31. // 启动过期检测
32. public void startExpiring() {
33. tasksMap.getExpirer().setTimeToLive(requestTimeout);
34. tasksMap.getExpirer().startExpiringIfNotStarted();
35. }
36.
37. // 停止过期检测
38. public void stopExpiring() {
39. tasksMap.getExpirer().stopExpiring();
40. }
41.
42. // 取任务列表.
43. public Object getTasks(String key) {
44. return tasksMap.get(key);
45. }
46.
47. // 去除任务列表.
48. public Object removeTasks(String key) {
49. return tasksMap.remove(key);
50. }
51.
52. // 添加任务列表.
53. public void addTasks(String key, Object value) {
54. tasksMap.put(key, value);
55. }
56. }
单例类也可以是没有状态的（stateless），仅用做提供工具性函数的对象。既然是为了提供工具性函数，也就没有必要创建多个实例，因此使用单例模式很合适。平常的单例类都是没有状态的，这里就不示例了。一个没有状态的单例类也就是不变（Immutable）单例类。
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中的有状态和无状态:
Servlet体系结构是建立在Java多线程机制之上的，它的生命周期是由Web 容器负责的。一个Servlet类在Application中只有一个实例存在，也就是有多个线程在使用这个实例。这是单例模式的应用。无状态的单例是线程安全的，但我们如果在Servlet里用了实例变量，那么就变成有状态了，是非线程安全的。如下面的用法就是不安全的,因为user,out都是有状态信息的。
1. /**
2. * 非线程安全的Servlet。
3. * @author Peter Wei
4. *
5. */
6. public class UnSafeServlet HttpServlet{
7.
8. User user;
9. PrintWriter out;
10.
11. public void doGet (HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException{
12. //do something...
13. }
14. }
Out,Request,Response,Session,Config,Page,PageContext是线程安全的,Application在整个系统内被使用,所以不是线程安全的
