java中lock与synchronized同步的解析

最新推荐文章于 2023-09-01 08:40:49 发布

bestone0213

最新推荐文章于 2023-09-01 08:40:49 发布

阅读量4.9k

点赞数 1

分类专栏： java

java 专栏收录该内容

52 篇文章 0 订阅

订阅专栏

现在soa 与分布式计算已经成为互联网公司技术的标配

那他包含的知识点应该熟悉了解，并以此为基础，去应用，调优各种soa的框架。

包含如下的四点，是分布式的基础。

a java 多线程承接高吞吐量。

b java nio 承接高并发，与交互协议的定制。

c java 反射完成序列化与反序列化。

d 设计模式的应用保证应用的扩展性。

接上篇

因为说锁的原理比较的枯燥，得带着问题场景去说，才能看下去，才能研究下去。

在Java中Lock接口比synchronized块的优势是什么？你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？

这里主要是要考察说lock与synchronized 的区别。

1 利用cpu底层机制lock有读锁与写锁的区分。

2 在于上下文的切换与锁的竞争的优化。

3 关于死锁的避免

Synchronized 只是jvm里面自己的一个协议;

而关于这个Lock 他的底层里面是有硬件支持的原子操作,各种cpu都支持的，各种平台也支持。如果需要详细理解，可以看看里面的源码，里面有一个重要的类就是AbstractQueuedSynchronizer, 它是轮询处理。

synchronized 在取不到锁的时候，会休眠一段时间，这样要说开销很大。当然这种synchronized 内部是后面的版本可以进行优化的。

1 利用cpu底层机制lock有读锁与写锁的区分。

那实现上面题干的两种方式如下

synchronized例子

代码如下

[java]view plaincopy 
   
 public class SynchronizedMap<K,V> {  
  private final Map<K,V> map=new HashMap<K, V>();  
    
    
    public synchronized void put(K k,V v){  
     map.put(k, v);  
    }  
    
    public synchronized V get(K k){  
     return map.get(k);  
    }  

这种排斥了写/写，读/写读/读。

对于lock，相关代码如下。

[java]view plaincopy 
   
 public class LockMap<K, V> {  
  private final Map<K, V> map=new HashMap<K, V>();  
  private final ReadWriteLock lock=new ReentrantReadWriteLock();  
  private final Lock r=lock.readLock();  
  private final Lock w=lock.writeLock();  
    
    
    
  public void put(K key,V value){  
   w.lock();  
   try {  
    map.put(key, value);  
   } catch (Exception e) {  
    e.printStackTrace();  
   }finally{  
    w.unlock();  
   }  
    
  }  
    
  public V get(K key){  
   r.lock();  
   try {  
    return map.get(key);  
   } catch (Exception e) {  
    e.printStackTrace();  
   }finally{  
    r.unlock();  
   }  
   return null;  
  }  
    
    
 }  

这种排斥了写/写读/写。
但读/读没有排斥。

也是就说读与读是多个线程可以同时读的。----可以做为读多写少的应用。

2在于上下文的切换与锁的竞争的优化。

对于 synchronized 来说。他只有一个条件队列的，里面放着对应于不同类型的（也可以说是处理不同业务类型的）线程，那这时，你只能notifyall
    ，为了保证程序的正确，把所有的线程都叫起来，不管是不是你想要的业务类型的线程。这种对于性能影响是非常大的。比如10个线程在一个条件队列上等待，那么调用notifyAll 将唤醒所有的线程
   这个时候线程产生如下：
       a 它们会在锁上面产生竞争。
       b 它们竞争完了之后大部分又大部分wait了
         这两步，会导致了大量的线程上下文切换。以及大量锁的竞争。

但这个lock是没问题的。他可以对于不同的条件创建wait-set ，比如生产者消费者模式，生产者生产一个对象，这时想唤醒消费者，只需要在相应的条件上面的wait set进行single.

对于线程安全的lock队列,与线程安全的synchronized stack代码

synchronized 代码如下

[java]view plaincopy 
   
 public class ProductStack {  
   
     private Product[] products=new Product[10];  
     private int index;  
       
       
     public synchronized void addProduct(Product product){  
         try {  
             while(index>=(products.length-1)){//需要重新检查一下，条件判断s  
                 System.out.println(" the product array is full ; "+Thread.currentThread().getName()+" is waiting");  
                 wait();  
             }  
                   
                 products[index]=product;  
                 index++;  
                 notifyAll();//为了能启动消费线程 当然也唤醒了生产线程。  
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
     }  
       
       
     public synchronized Product pop(){  
         Product product=null;  
         try {  
               
             while(index<=0){ //需要重新检查一下，条件判断  
                 System.out.println("the product array is empty ;"+Thread.currentThread().getName() +"is waiting");  
                 wait();  
             }     
                 index--;   
                 product=products[index];  
                 notifyAll();   //为了能启动 添加线程。 当然也唤醒了消费线程。  
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
           
         return product;  
     }  
 }  

对于lock

[java]view plaincopy 
   
 import java.util.concurrent.locks.Condition;  
 import java.util.concurrent.locks.Lock;  
 import java.util.concurrent.locks.ReentrantLock;  
   
 public class ProductQueue<V> {  
     private final static int defaultSize=10;  
     private final V[] queue;  
     private int total;  
     private int tail;  
     private int head;  
     private Lock lock=new ReentrantLock();  
     private Condition notEmpty=lock.newCondition();  
     private Condition notFull= lock.newCondition();  
       
       
     public ProductQueue(){  
           
         this(defaultSize);  
     }  
       
     public ProductQueue(int initialCapacity) {  
         super();  
         this.queue = (V[])new Object[initialCapacity];  
     }  
       
       
     public void push(V v) throws InterruptedException{  
         lock.lock();  
         try {  
             while (isFull()) {  
                 notFull.await();  
             }  
               
             queue[tail] = v;  
             ++tail;  
             if (tail == queue.length)  
                 tail = 0;  
             total++;  
             notEmpty.signal();//唤醒的是同一种类型的线程,不会浪费。  
               
         } finally{  
             lock.unlock();  
         }  
           
     }  
       
       
       
     public V pop() throws InterruptedException{  
         lock.lock();  
         try {  
             while(isEmpty()){  
                 notEmpty.await();  
             }  
             V v=queue[head];  
             head++;  
             if(head==queue.length)head=0;  
             total--;  
             notFull.signal();//唤醒的是同一种类型的线程,不会浪费。  
             return v;  
         } finally{  
             lock.unlock();  
         }  
     }  
       
       
     public boolean isEmpty(){  
         return total==0;  
     }  
     public boolean isFull(){  
         return total==queue.length;  
     }  
       
   
 }  

注解里面解释到了问题的根本。

notifyall 时将所有的线程，生产者，消费者都唤醒了。而此时你只想唤醒生产者，或者只想唤醒消费者，让你胡子眉毛一把抓

3 关于死锁的避免

   产生死锁的本质：至少有两把以上的锁，每个线程获取锁的方式不会一样。实际应用中会有如下3种情况，出现死锁
a 同一类对象
    第一个方法
       synchronized(LockA){
                synchronized(LockB){
                       }
         }

       第二个方法
              synchronized(LockB){
                   synchronized(LockA){
                             doSomeThing.......
                  }
             }
   以上情况的解决方案是，顺序不一样，把顺序搞一样就成。
b 对于方法 public void A(SameObject a,SameObject b){
                            synchronized(a){
                                                 synchronized(b){
                                                                                                    doSomeThing.......
                                                        }
                                                            }

                        }
这里会产生死锁的可能，原因是根据参数的顺序就能有可能被锁了。这时可以用并发包里面的tryLock最简单。         以上是在同一个类里面。
b 这种情况，是在两个类里面，可以想象成为两个资源，
                       在类A里面的有一个a 方法是同步的。
                       在类B里面的有一个b 方法是同步的。
                       a 里面调b方法。
                       b 里面调a方法。
    这里就会产生死锁，因为获取锁的顺序不一样。这种情况的解决方案是，将方法上的所有的synchronized的都去掉，换成同步块，但同步块同是将传过来的资源，进行一个copy. 这个在并发包里面的有些集合可以参考的。全局，分析锁的个数，获取的顺序。顺序好说，那怎么分析？
怎么去分析死锁呢？
a 争取用同步块，把不能同步方法，从业务角度保证开方式调用。
b 用线程堆栈信息来分析（kill -3）的方式。
c 对于业务的拆解。理论上没有死锁，但是锁管理的资源，在线程处理的时候，占时太长，将业务就要进行重构了。

d 加一功能代码代码如下

[java]view plaincopy 
   
 ThreadMXBean tmx = ManagementFactory.getThreadMXBean();  
   long[] ids = tmx.findDeadlockedThreads();  
   if (ids != null) {  
      ThreadInfo[] infos = tmx.getThreadInfo(ids, true, true);  
      System.out.println("The following threads are deadlocked:");  
      for (ThreadInfo ti : infos) {  
         System.out.println(ti);  
      }  
     }  

bestone0213

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
java中lock与synchronized同步的解析

现在soa 与分布式计算已经成为互联网公司技术的标配那他包含的知识点应该熟悉了解，并以此为基础，去应用，调优各种soa的框架。包含如下的四点，是分布式的基础。 a java 多线程承接高吞吐量。 b java nio 承接高并发，与交互协议的定制。 c java 反射完成序列
复制链接

扫一扫