线程安全性的定义：

在多个线程访问某个类时，不管运行环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，那么我们就说这个类是线程安全的。

无状态对象：

不包含任何域，也不包含对其他类中域的引用。

一个无状态的对象，一定是线程安全的。

比如我们平时写的Servlet。

PS：Servlet中可能包含一个Dao域，但是在和Dao本身也是无状态的，我们本身是可以将Dao的代码直接分解到Servlet中，不需要Dao。但是为了实现代码解耦的效果，加入了Dao。

竞态条件

竞态条件（race condition），从多进程间通信的角度来讲，是指两个或多个进程对共享的数据进行读或写的操作时，最终的结果取决于这些进程的执行顺序。

常见的竞态条件如：先检查后执行。

原子操作：

一些简单的竞态条件，可以通过原子操作，解决。

如通过AtomicInteger的incrementAndGet()解决计数器的竞态条件

加锁机制：

复杂的竞态条件需要使用锁来解决。

每个java对象都有一个内置的锁，这个锁被称为内置锁或者监视锁。在这个对象内部的方法上(非static方法)的使用synchronized就是默认使用的这个锁。

内置锁是互斥的，可重入的。

用锁来保护状态

对于可能被多个线程同时访问的可变状态变量，在访问它时都需要持有同一个锁，这种状态下，我们成状态变量时由这个锁保护的。

活跃性和性能

一些概念：

安全性是指"永远不会发生糟糕的事情"，我们使用锁和同步就是为了保证安全性。

活跃性是指"某件正确的事情最终会发生"，当某个操作不能执行下去，就会出现活跃性问题，如死循环。

性能问题：响应时间，吞吐率，资源消耗，伸缩性等。

我们可以通过锁来解决安全问题，但是也要兼顾活跃性和性能。

重要的是不要粗暴的直接在一个复杂的方法上加synchronize，而是分解。我们看一个例子：

package com.zjf;
import java.math.BigInteger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* 一个获取用于计算整数的平方的类
* 实现了缓存
* @author hadoop
*
*/
public class PowerCache {
//使用全局变量作为竞争资源
public static final PowerCache pc = new PowerCache();
//记录上一个传入的数值为多个线程共享
private BigInteger lastNumber;
//记录上一个计算的平方结果为多个线程共享
private BigInteger lastPower;
//记录power方法调用了多少次为多个线程共享
private long hits;
//记录命中缓存的次数为多个线程共享
private long cacheHits;
//访问了共享数据注意标注方法为synchronized
public synchronized long getHits()
{
return hits;
}
//访问了共享数据注意标注方法为synchronized
public synchronized long getCacheHit()
{
return cacheHits;
}
//命中缓存的概率访问了共享数据注意标注方法为synchronized
public synchronized double getCacheHitRatio()
{
return (double)cacheHits / (double) hits;
}
public BigInteger power(BigInteger i)
{
BigInteger power = null;
//分割对比和命中缓存部分为一个synchronized
synchronized(this) {
hits++;
if(i.equals(lastNumber))
{
power = lastPower;
cacheHits++;
}
}
if(power == null)
{
//将计算这种耗时逻辑放在synchronized外部
power = i.pow(2);
//分割的第二个synchronized块用于没有命中的结果需要记录进缓存
synchronized (this) {
lastNumber = i;
lastPower = new BigInteger(power.toString());//复制一份这一步骤有问题其实不用复制这是多此一举因为BigInteger是不可变对象
}
}
return power;
}
//测试逻辑
public static void main(String[] args) throws InterruptedException {
PowerCache pc = new PowerCache();
ExecutorService es = Executors.newCachedThreadPool();
for(int i = 0; i < 100; i++)
{
es.execute(new Runnable() {
public void run() {
BigInteger bi = BigInteger.valueOf((long)(Math.random() * 10));
System.out.println(bi + ":" + PowerCache.pc.power(bi));
}
});
}
es.shutdown();
TimeUnit.MILLISECONDS.sleep(1000);
System.out.println(PowerCache.pc.getHits());
System.out.println(PowerCache.pc.getCacheHit());
System.out.println(PowerCache.pc.getCacheHitRatio());
}
}

要判断同步代码块的合理大小，需要在各种设计之间进行权衡，包括安全性，简单性，和性能。

当执行时间较长的计算或者无法快速完成的操作时，如网络IO或者控制台IO。一定不要持有锁。

线程

Java并发编程实战 第2章 线程安全性