线程安全及实现

线程安全

   什么是线程安全，概念？

首先线程安全是指：当多个线程访问某个方法时，不管你通过怎样的调用方式或者说这些线程如何交替的执行，我们在主程序中不需要去做任何的同步，这个类的结果行为都是我们设想的正确行为，那么我们就可以说这个类时线程安全的。

造成线程安全的一般是变量，全局变量、静态变量，成员变量

  那么怎么实现线程安全呢？

1、加关键字实现，加锁。

synchronize，同步代码块，重量级锁

    在java中，每一个对象都拥有一个锁标记，monitor，称为监视器，当多个线程同时访问对象时，线程只有获得了对象的锁才能访问。

    在java中，synchronized可以用来修饰方法和代码块。当某个线程调用对象的synchronized方法和访问synchronized方法时，必须要先获得对象的锁才可以继续访问，当该线程获得锁时，其他线程暂时无法访问这个方法，只有等待这个方法执行完毕或者代码块执行完毕，这个线程才会释放该对象的锁，其他线程才能执行这个方法或者代码块。

释放锁

1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；

2）线程执行发生异常，此时JVM会让线程自动释放锁。

但是如果出现，由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了的情况就会一直占有锁

2、lock实现,java.util.concurrent.locks,并发包里面的

    lock是一个接口，看lock的源码就可以知道，lock里面有很多方法

public interface Lock {
    void lock();//获取锁，如果不能获取则等待
    void lockInterruptibly() throws InterruptedException;//获取不到锁的情况下可以中断等待，不能中断已经获取锁的线程
    boolean tryLock();//尝试获取锁，马上返回是否获取到锁
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;//尝试获取锁，等待一段时间返回是否获取到锁
    void unlock();//释放锁
    Condition newCondition();
}

里面的方法决定了lock可以进行获取锁和主动释放锁

可以灵活的获取锁和释放锁，中断等待

//lock来同步实现
Lock lock = ...;
lock.lock();
try{
    //处理任务
}catch(Exception ex){
     
}finally{
    lock.unlock();   //释放锁
}
//tryLock()实现同步
Lock lock = ...;
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){
         
     }finally{
         lock.unlock();   //释放锁
     } 
}else {
    //如果不能获取锁，则直接做其他事情
}
//中断等待
public void method() throws InterruptedException {
    lock.lockInterruptibly();
    try {  
     //.....
    }
    finally {
        lock.unlock();
    }  
}

Lock和synchronized的选择

　　总结来说，Lock和synchronized有以下几点不同：

　　1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

　　2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

　　3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

　　4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

　　5）Lock可以提高多个线程进行读操作的效率。

　　在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择

读写锁补充

readlock和writelock，可以有多个读线程，只能有一个写线程。读写不能共存。

读线程可以进入已经获取读锁

通常为了处理读线程长期占用，会进行处理。当读线程占有的时候，有写线程会堵塞后面的读线程。不然写线程可能长时间无法获取锁

3、jdk1.5以后ConcurrentHashMap,CountDownLatch

ConcurrentHashMap的设计与实现非常精巧，大量的利用了volatile，final，CAS等lock-free技术来减少锁竞争对于性能的影响