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 是使用读-写锁定的理想候选者。  

    原文作者:流氓剑客
    原文地址: http://www.cnblogs.com/lmjk/articles/7478280.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞