多线程同时安全地调用被称为线程安全。如果一段代码是线程安全的，那么它不包含任何竞争条件。竞争条件仅在多个线程更新共享资源时发生。因此，重要的是要知道什么共享资源会被多线程同时执行。
局部变量
局部变量存储在每个线程自己的堆栈中。这意味着局部变量从不在线程之间共享。这也意味着所有本地变量基本上都是线程安全的。以下是本地变量的线程安全的示例：
publicvoid someMethod(){
longthreadSafeInt = 0;
threadSafeInt++;
}
本地对象的引用
引用本身不是共享的。但是，引用的对象不存储在每个线程的本地堆栈中，所有对象都存储在共享堆中。
如果本地创建的对象永远不会通过创建他的方法返回，那么它是线程安全的。实际上，只要没有让对象在方法之间传递后用于其他线程。
这是一个线程安全的本地对象的示例：
publicvoid someMethod(){
LocalObject localObject =new LocalObject();
localObject.callMethod();
method2(localObject);
}publicvoid method2(LocalObject localObject){
localObject.setValue("value");
}
上面这个例子，someMethod()这个方法没有将LocalObject传递出去，而是每个线程调用someMethod()都会创建一个新的LocalObject，并在自己的方法内部消化，所以这里是线程安全的。
对象成员变量
对象成员变量与对象一起存储在堆上。因此，如果两个线程调用同一对象实例上的方法，并且此方法更新该对象的成员变量，则该方法是线程不安全的。这是一个线程不安全的例子：
publicclass NotThreadSafe{
StringBuilder builder =new StringBuilder();
public add(String text){
this.builder.append(text);
}
}
如果两个线程在同一个NotThreadSafe实例上同时调用add()方法，那么它会导致竞争条件。例如：
NotThreadSafe sharedInstance =new NotThreadSafe();newThread(new MyRunnable(sharedInstance)).start();newThread(new MyRunnable(sharedInstance)).start();publicclassMyRunnableimplements Runnable{
NotThreadSafe instance =null;
public MyRunnable(NotThreadSafe instance){
this.instance = instance;
}
publicvoid run(){
this.instance.add("some text");
}
}
但是，如果两个线程在不同的实例上同时调用add()方法 ，那么它们不会产生竞争条件。把上面的例子稍加修改：
newThread(newMyRunnable(new NotThreadSafe())).start();
newThread(newMyRunnable(newNotThreadSafe())).start();
现在这两个线程都拥有自己的实例对象，所以他们调用add方法时不会互相干扰。代码没有竞争条件了。所以即使一个对象是线程不安全的，它仍然可以以不会导致竞争条件的方式运行。
线程控制逃离准则（The Thread Control Escape Rule）
为了确定你的代码对某个资源的访问是否是线程安全的，您可以使用“线程控制逃离准则”：
如果一个资源的创建、使用和回收都在同一个线程内完成的，并且从来没有逃离这个线程的控制域，那么该资源就是线程安全的
If a resource is created, used and disposed within the control of the same thread, and never escapes the control of thisthread, the use of that resource is thread safe.
资源可以是任何形式的共享资源，如对象，数组，文件，数据库连接，套接字等。在Java中，你并不总是明确地回收某个对象，因此“回收”意味着对该对象的引用不再使用或者置为 null。
即使使用线程安全的对象，如果该对象指向一个共享资源，如文件或数据库，那么整个应用程序可能不是线程安全的。例如，如果线程1和线程2都创建自己的数据库连接，连接1和连接2，则使用每个连接本身是线程安全的。但是使用数据库的连接点可能不是线程安全的。例如，如果两个线程执行这样的代码：
checkif record X existsifnot, insert record X
如果两个线程同时执行，并且他们正在检查的记录X恰好是相同的记录，那么就存在两个线程都进行插入的动作。那么这就是线程不安全的。
这种情况也可能发生在对文件或者其他共享资源的操作上。因此，一定要区分一个线程所控制的对象到底是资源本身还是指向资源的一个引用。
竞争条件只有在多个线程同时访问同一资源且多个线程同时写入资源时才会发生。如果多线程读取相同的资源，那么竞争条件不会发生。
我们可以通过让共享对象不可变来确保多线程永远不会更新该对象，从而保证线程安全。例如：
publicclass ImmutableValue{
privateintvalue = 0;
publicImmutableValue(int value){
this.value = value;
}
publicint getValue(){
returnthis.value;
}
}
注意ImmutableValue实例的属性value在构造函数中赋值。还要注意该没有提供setter方法。一旦ImmutableValue实例被创建，你不能改变它的属性value。当然，您可以使用该getValue()方法读它。
如果需要对ImmutableValue实例执行操作，可以通过操作得到返回一个新的实例来改变value的值，从而不改变原实例的value值。看下面例子会更加清晰：
publicclass ImmutableValue{
privateintvalue = 0;
publicImmutableValue(int value){
this.value = value;
}
publicint getValue(){
returnthis.value;
}
publicImmutableValue add(int valueToAdd){
returnnewImmutableValue(this.value + valueToAdd);}
}
请注意该add()方法返回的是一个新实例，而不是改变自身实例的value值。
非常重要的是，即使一个对象是不可变的，因此是线程安全，但该对象的引用可能不是线程安全的。例如：
publicclass Calculator{
privateImmutableValue currentValue =null;
public ImmutableValue getValue(){
return currentValue;
}
publicvoid setValue(ImmutableValue newValue){
this.currentValue = newValue;
}
publicvoidadd(int newValue){
this.currentValue =this.currentValue.add(newValue);
}
}
Calculator类持有一个ImmutableValue实例的引用。但是Calculator可以通过方法setValue() 和add()方法来改变引用。因此，即使Calculator类在内部使用不可变对象ImmutableValue，但它本身不具有不变性，因此是线程不安全的。换句话说：ImmutableValue该类是线程安全的，但使用它的不是。当尝试通过不变性实现线程安全性时，需要牢记这一点。
为了使Calculator类线程安全，你可以将getValue()， setValue()和add()方法加synchronized。
