java中线程安全的实现方法

1、互斥同步（悲观并发）

互斥包括的几种方式：临界区、互斥量（wait(),notify()）、信号量（synchronized、java.util.concurent）

synchronized 是一个重量级的锁，因为线程的切换需要操作系统的调用。如果一个线程要获取一个对象，首先获取对象的锁，如果对象已经加锁，将计数值+1，如果释放对象的锁，则计数值-1。

也可以使用Lock lock=new ReetrantLock();

try{

lock.lock()

}finally{

lock.unlock();

}

这个类是可重入类，有新的特性，（1）公平锁，（2）等待可中断，（3）可以为多个Condition加锁

2、非阻塞法同步（基于冲突检测的乐观并发）

主要使用的就是CAS+失败重试

package ThreadSafety;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * Atomic变量自增运算测试
 * 
*/
public class AtomicTest {
    public static AtomicInteger race = new AtomicInteger(0);


    public static void increase() {
        race.incrementAndGet();
    }
    private static final int THREADS_COUNT = 20;

    public static void main(String[] args) throws Exception {
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }
        while (Thread.activeCount() > 1)
            Thread.yield();
        System.out.println(race);
    }
}
使用AtomicInteger 这个类，保证在多线程的情况下并发安全 ，同时也可以提高效率相对于阻塞同步

3、无同步方案

将变量保存在本地线程中，就不会出现多个线程并发的错误了。

java中主要使用的就是ThreadLocal这个类。