Synchronized/Lock/Volatile

在Java中，提供了两种方式来实现同步互斥访问：synchronized和Lock。对临界资源加上互斥锁，当一个线程在访问该临界资源时，其他线程便只能等待。每一个对象都拥有一个锁标记（monitor），也称为监视器，多线程同时访问某个对象时，线程只有获取了该对象的锁才能访问。当某个线程调用该对象的synchronized方法或者访问synchronized代码块时，这个线程便获得了该对象的锁。

synchronized：
当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块而synchronized(this)同步代码块的访问将被阻塞（这里是指所有的同步方法/代码块，而不仅仅是同一个方法/代码块）。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
被修饰的同步代码块，其作用的范围是调用这个代码块的对象，我们在用synchronized关键字的时候，尽量缩小代码段的范围，能在代码段上加同步就不要再整个方法上加同步。减小锁的粒度，使代码更大程度的并发。

• synchronized方法，被修饰的方法成为同步方法，其作用范围是整个方法，作用对象是调用这个方法的实例。
• synchronized静态方法，修饰一个static静态方法，其作用范围是整个静态方法，作用对象是这个类的所有实例。
• synchronized类锁，synchronized(className.class)，作用的对象是这个类的所有实例。

synchronized()方法中是锁住的对象，即synchronized(this)锁住的只是实例本身，同一个类的不同实例调用的synchronized方法并不会被锁住，而synchronized(className.class)实现了全局锁的功能，所有这个类的实例调用这个方法都受到锁的影响，此外()中还可以添加一个具体的实例，实现给具体实例加锁。

public class Thread1 implements Runnable {  
     public void run() {  
          synchronized(this) {  
               for (int i = 0; i < 5; i++) {  
                    System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);  
               }  
          }  
     }  
     public static void main(String[] args) {  
          Thread1 t1 = new Thread1();  
          Thread1 t1_2 = new Thread1();  
          Thread ta = new Thread(t1, "A");  
          Thread tb = new Thread(t1, "B");  //ta与tb互斥
          Thread tc = new Thread(t1_2, "C");//tc与ta，tb不互斥
          ta.start();  
          tb.start();  
          tc.start();  
     } 
}

synchronized 静态：
如果一个线程执行一个实例的非静态的synchronized方法，另外一个线程需要执行这个实例静态的 synchronized方法，此时不会发生互斥现象，因为访问static synchronized方法占用的是类锁，而访问非static的synchronized方法占用的是实例锁，所以不存在互斥现象。

synchronized(A.class) {  
    ... //锁住了类（包括静态成员）的同步代码块
}  

如下Something类的两个实例x与y，那么下列组方法可以被1个以上线程同时访问呢?

pulbic class Something(){ 
　　public synchronized void isSyncA(){} 
　　public synchronized void isSyncB(){} 
　　public static synchronized void cSyncA(){} 
　　public static synchronized void cSyncB(){} 
}

a.   x.isSyncA()与x.isSyncB() 
b.   x.isSyncA()与y.isSyncA() 
c.   x.cSyncA()与y.cSyncB() 

a的话是同个实例中的，故不可以。
b中是不同实例的，所以可以同时访问。
c中是针对static synchronized，上文所说所有的static方法共用一个监视块，故不能够同时访问。

Lock：
与synchronized的不同：

• Lock支持在等待一定的时间或者能够响应中断。
• Lock支持在多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。
• 通过Lock可以知道线程有没有成功获取到锁。
• Lock不是Java语言内置的。synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问。
• Lock必须要用户去手动释放锁，而synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用。

ReentrantLock是实现了Lock接口的类，用lock改写上面的synchronized方法：

public class MyThread implements Runnable {  

     private Lock lock = new ReentrantLock();

     public void run() {
        //Lock lock = new ReentrantLock();    //注意变量lock的范围
        lock.lock();
        try {
            for (int i = 0; i < 5; i++) {  
                System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);  
            }  
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
     }  

     public static void main(String[] args) {  
          MyThread t1 = new MyThread();  
          MyThread t2 = new MyThread();  
          Thread ta = new Thread(t1, "A");  
          Thread tb = new Thread(t1, "B");  //ta与tb互斥
          Thread tc = new Thread(t2, "C");//tc与ta，tb不互斥
          ta.start();  
          tb.start();  
          tc.start();  
     } 
}

注意如果lock变量是局部变量，每个线程执行该方法时都会保存一个副本，那么理所当然每个线程执行到lock.lock()处获取的是不同的锁，所以就不会发生冲突，也就没有起到lock的效果。

tryLock()：
tryLock()表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果在等待期间内拿到了锁，则返回true。

private Lock lock = new ReentrantLock();

public void mySyncMethod() {
    if(lock.tryLock()) {
         try{
             //处理任务
         }catch(Exception ex){
             
         }finally{
             lock.unlock();   //释放锁
         } 
    }else {
        //如果不能获取锁，则直接做其他事情
    }
}

读写锁：

 private ReentrantReadWriteLock rwlock = new ReentrantReadWriteLock();

 public void mySyncMethod() {
     rwl.readLock().lock();
     try{
         //处理任务
     }catch(Exception ex){
         
     }finally{
         lock.unlock();   //释放锁
     } 
 }

这样就提升了读操作的效率。不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

Volatile：
volitile的使用场景，通过关键字sychronize可以防止多个线程进入同一段代码，在某些特定场景中，volitile相当于一个轻量级的sychronize，因为不会引起线程的上下文切换，一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

• 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。volatile关键字会强制将修改的值立即写入主存，使线程的工作内存中缓存变量行无效。
• 禁止进行指令重排序。

在java虚拟机的内存模型中，有主内存和工作内存的概念，每个线程对应一个工作内存，并共享主内存的数据。

• 对于普通变量：读操作会优先读取工作内存的数据，如果工作内存中不存在，则从主内存中拷贝一份数据到工作内存中；写操作只会修改工作内存的副本数据，这种情况下，其它线程就无法读取变量的最新值。

• 对于volatile变量，读操作时JMM会把工作内存中对应的值设为无效，要求线程从主内存中读取数据；写操作时JMM会把工作内存中对应的数据刷新到主内存中，这种情况下，其它线程就可以读取变量的最新值。

  
  
  
  
  
  

但是volatile关键字最致命的缺点是不支持原子性。synchronized关键字是防止多个线程同时执行一段代码，那么就会很影响程序执行效率，而volatile关键字在某些情况下性能要优于synchronized，但volatile关键字是无法替代synchronized关键字的，因为volatile关键字无法保证操作的原子性。通常来说，使用volatile必须具备以下2个条件：

• 对变量的写操作不依赖于当前值。
• 该变量没有包含在具有其他变量的不变式中。

---

参考：

http://blog.csdn.net/chengguotao/article/details/50498090