java线程锁

一、synchronized
         这货可以锁对象，锁变量，锁方法，锁代码，好像什么都能锁，缺点就是如果一个锁堵了，其他的只能等待忙并不能把当前的锁给释放。
二、 ReentrantLock
ReentrantLock 类实现了Lock ，它拥有与synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。

• class Outputter1 {    
•     private Lock lock = new ReentrantLock();// 锁对象    
•   
•     public void output(String name) {           
•         lock.lock();      // 得到锁    
•   
•         try {    
•             for(int i = 0; i < name.length(); i++) {    
•                 System.out.print(name.charAt(i));    
•             }    
•         } finally {    
•             lock.unlock();// 释放锁    
•         }    
•     }    
• }  

三、ReadWriteLock

读写分离，读的有多个，写的只有一个，看代码
    

• class Data {        
•     private int data;// 共享数据    
•     private ReadWriteLock rwl = new ReentrantReadWriteLock();       
•     public void set(int data) {    
•         rwl.writeLock().lock();// 取到写锁    
•         try {    
•             System.out.println(Thread.currentThread().getName() + "准备写入数据");    
•             try {    
•                 Thread.sleep(20);    
•             } catch (InterruptedException e) {    
•                 e.printStackTrace();    
•             }    
•             this.data = data;    
•             System.out.println(Thread.currentThread().getName() + "写入" + this.data);    
•         } finally {    
•             rwl.writeLock().unlock();// 释放写锁    
•         }    
•     }       
•   
•     public void get() {    
•         rwl.readLock().lock();// 取到读锁    
•         try {    
•             System.out.println(Thread.currentThread().getName() + "准备读取数据");    
•             try {    
•                 Thread.sleep(20);    
•             } catch (InterruptedException e) {    
•                 e.printStackTrace();    
•             }    
•             System.out.println(Thread.currentThread().getName() + "读取" + this.data);    
•         } finally {    
•             rwl.readLock().unlock();// 释放读锁    
•         }    
•     }    
• } 

 

与互斥锁定相比，读-写锁定允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程（writer 线程）可以修改共享数据，但在许多情况下，任何数量的线程可以同时读取共享数据（reader 线程）

从理论上讲，与互斥锁定相比，使用读-写锁定所允许的并发性增强将带来更大的性能提高。

在实践中，只有在多处理器上并且只在访问模式适用于共享数据时，才能完全实现并发性增强。——例如，某个最初用数据填充并且之后不经常对其进行修改的 collection，因为经常对其进行搜索（比如搜索某种目录），所以这样的 collection 是使用读-写锁定的理想候选者。