Single Threaded Execution 也称为 Critical  Section 临界区：危险区域 或者Critical Region 

Single Threaded Execution 是把视点放在运行的线程上所取的名称 

而Critical Session 或Critical Region 则是把视点放在执行的范围上所取的名称

/**

*Gate 类   这个是线程安全的

*/

public class Gate{
private int counter=0;
private String name="Nobody";
private String address="Nowhere";

public synchronized void pass(String name,String address){  //synchronized 
this.counter++;
this.name=name;
this.address=address;
check();
}
public synchronized String toString(){    //synchronized 
return "NO."+counter+":"+name+","+address;
}
private void check(){
if(name.charAt(0)!=address.charAt(0)){
System.out.println("******BROKEN****"+toString());
}
}
}

-------------------------------------------------------------

/**
* UserThread
*/
public class UserThread extends Thread{
private final Gate gate;
private final String myname;
private final String myaddress;
public UserThread(Gate gate,String myname,String myaddress){
this.gate=gate;
this.myname=myname;
this.myaddress=myaddress;
}
public void run(){
System.out.println(myname+"BEGIN");
while(true){
gate.pass(myname, myaddress);
}
}

}

---------------------------------------------

public class MainTest {

/**
* main
* */
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("Testing Gate");
Gate gate=new Gate();
new UserThread(gate,"AA","AAA").start();
new UserThread(gate,"BB","BBB").start();
new UserThread(gate,"CC","CCC").start();
}

}

之所以会显示BROKEN 是因为pass方法内的程序坑内会被多个线程穿插执行

synchronized方法，能够保证同时只有一个线程可以执行它

就是说 线程A执行pass方法的时候，线程B就不会调用pass方法，在线程A执行完pass方法之前，线程B会在pass方法的入口处被阻挡下，当线程A执行完pass方法后，将锁定解除线程B才可以开始执行pass方法

所以只要将pass方法生民成synchronized的方法，就绝对不会出现BROKEN 

而toString方法需要加上synchronized的理由，与check方法不加上synchronized的理由。。。。。。 

SafeMethod  从多个线层同时调用也不会发生问题的方法   （安全的方法，并不需要特别的处理）

UnsafeMethod 从多个线程同时调用会出问题，而需要加以防护的方法（不安全的方法 则是被多个线程同时执行，可能会使实例的状态产生矛盾的方法，所以必须加以防卫，使同时不能有多个线程同时执行这个方法）

---------------------------------------

单线程程序，并不需要使用Single Threaded　Execution Pattern 因此 也不需要使用synchronized方法

即使使用也不会对程序的安全性造成危害，但是会多花时间，所以会使程序性能略微降低

会需要使用 SingleThreaded Execution Pattern 的情况 ，是在SharedResource的实例可能同时被多个线程访问的时候

就算是多线程程序，如果所有线程完全地独立运行也没有使用S E P的必要，这个状态称为线程互不干涉（interfere）

有些管理多线程的环境，会帮我们确保线程的独立性，这种情况下这个环境的用户就不必考虑需不需要使用single threaded EP的必要

在immutable pattern中，实例的状态不会改变，所以是不需要用到synchronized方法的一种 pattern

只有需要确保安全性的时候，才会需要使用 SingleThreaded Execution Pattern

java2的集合架构类多半并非线程安全。这是为了在不考虑安全性的时候，可以让程序的运行速度较高

所以用户需要考虑自己要用的类需不需要考虑线程安全再使用

-------------

线程安全的包装方法（Wrapper）用来让集合架构类可以线层安全地运行

synchronizedCollection方法

synchronizedList方法

synchronizedMap

synchronizedSet

synchronizedSortedMap

synchronizedSortedSet

临界区的大小与执行性能

一般来说SingleThreaded Execution Pattern 会使程序执行性能低落的原因有两个

获取锁定要花时间-----若见啥SharedResource参与者的数量，就能减少需要获取的锁定数，可以减少性能低落的幅度

线程冲突时必须等待----当线程A执行临界区内的操作时，其他要进入临界区额线程会被阻挡。这个状态称之为冲突（conflict）当冲突发生时，线程等待的时间就会使整个线程性能往下掉

-------尽可能缩小临街区范围，以减少出现线程冲突的机会，可抑制性能的降低

SingleThreaded Execution Pattern与多线程，并发性相关的许多Pattern都有关联、

Single Threaded Execution