Lock与synchronized对比

Love The Way You Lie 2021-09-27 14:26 338阅读 0赞

<table> 
 <thead> 
  <tr> 
   <th>Lock接口方法</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>lock.lock</td> 
   <td>获取锁 阻塞</td> 
  </tr> 
  <tr> 
   <td>lock.tryLock</td> 
   <td>获取锁 成功返回true 失败false</td> 
  </tr> 
  <tr> 
   <td>lock.tryLock(1, TimeUnit.SECONDS)</td> 
   <td>等待制定时间 获取锁 成功返回true 失败false</td> 
  </tr> 
  <tr> 
   <td>lock.lockInterruptibly</td> 
   <td>注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出 调用Thread.interrupt方法打断</td> 
  </tr> 
  <tr> 
   <td>lock.unlock</td> 
   <td>释放锁</td> 
  </tr> 
  <tr> 
   <td>设置公平锁</td> 
   <td>Lock lock = new ReentrantLock(true);//true为公平锁</td> 
  </tr> 
 </tbody> 
</table>

synchronized 与 Lock接口功能区别

<table> 
 <thead> 
  <tr> 
   <th>类别</th> 
   <th>synchronized</th> 
   <th>Lock</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>存在层次</td> 
   <td>Java的关键字，在jvm层面上</td> 
   <td>是一个类</td> 
  </tr> 
  <tr> 
   <td>锁的释放</td> 
   <td>1、以获取锁的线程执行完同步代码，释放锁 2、线程执行发生异常，jvm会让线程释放锁</td> 
   <td>在finally中必须释放锁，不然容易造成线程死锁</td> 
  </tr> 
  <tr> 
   <td>锁的获取</td> 
   <td>假设A线程获得锁，B线程等待。如果A线程阻塞，B线程会一直等待</td> 
   <td>分情况而定，Lock有多个锁获取的方式，具体下面会说道，大致就是可以尝试获得锁，线程可以不用一直等待</td> 
  </tr> 
  <tr> 
   <td>锁状态</td> 
   <td>无法判断</td> 
   <td>可以判断</td> 
  </tr> 
  <tr> 
   <td>锁类型</td> 
   <td>可重入 不可中断 非公平</td> 
   <td>可重入 可判断 可公平（两者皆可）</td> 
  </tr> 
  <tr> 
   <td>性能</td> 
   <td>用CAS来实现</td> 
   <td>用CAS来实现</td> 
  </tr> 
  <tr> 
   <td>功能</td> 
   <td>synchronized的使用简单点</td> 
   <td>Lock提供的功能丰富点</td> 
  </tr> 
 </tbody> 
</table>

Demo简单示例

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * 
     * @author gyn 实现一个线程安全的计数器
     */
    public class Test100 implements Runnable {
    	public final static ExecutorService EXECUTOR = Executors.newFixedThreadPool(100);
    	public static volatile int li = 0;
    	public static volatile int si = 0;
    	public final static Lock lock = new ReentrantLock(true);//公平锁
    	/**
    	 * Lock实现
    	 */
    	public static void getLockInt() {
    		lock.lock();// 获取锁
    		try {
    			li++;
    		} catch (Exception e) {
    			// TODO: handle exception
    		} finally {
    			lock.unlock();// 释放锁
    		}
    
    	}
    	/**
    	 * synchronized关键字实现
    	 */
    	public static synchronized void getSynInt() {
    		si++;
    
    	}
    
    	@Override
    	public void run() {
    		// TODO Auto-generated method stub
    		for (int i = 0; i < 100; i++) {
    			getSynInt();
    		}
    		for (int i = 0; i < 100; i++) {
    			getLockInt();
    		}
    
    	}
    
    	public static void main(String[] args) throws InterruptedException {
    		for (int i = 0; i < 100; i++) {
    			EXECUTOR.execute(new Test100());
    		}
    		EXECUTOR.shutdown();
    		for (;;) {
    			// 判断线程池任务是否执行完毕
    			if (EXECUTOR.isTerminated()) {
    
    				System.out.println("Lock实现			li=" + Test100.li);
    				System.out.println("synchronized关键字实现	si=" + Test100.si);
    				break;
    			} else {
    				System.out.println("线程未结束");
    
    				Thread.sleep(200);
    			}
    
    		}
    	}
    }

控制台输出-----------------都是线程安全的

线程未结束
    Lock实现			li=10000
    synchronized关键字实现	si=10000