本文共 6413 字，大约阅读时间需要 21 分钟。

一，synchronized的缺陷

如果一个代码块被synchronized修饰，当一个线程获取了对应的锁，并执行该代码块，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况

1.获取锁的线程执行完该代码块，然后线程释放对锁的占有

2.线程执行发生异常，此时JVM会让线程自动释放锁

那么如果这个获取锁的线程由于要等待IO或者其他原因被阻塞了，但是又没有释放锁，其他线程便只能等待，将影响程序执行效率，so，需要一种机制可以不让等待的线程一直无期限等待下去（比如只等待一定的时间或者能够响应中断），Lock就可以

二，java.util.concurrent.locks包下常用的类

1.Lock

从源码可知，Lock是一个接口

public interface Lock {//	获取锁，如果锁已被其他线程获取，则进行等待	void lock();/* * lockInterruptibly方法获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态 * 当两个线程同时通过该方法 想获取某个锁，假若此时线程A获取了锁，线程B只有等待，对线程B调用threadB.interrupt()方法能中断线程B的等待 */	void lockInterruptibly() throws InterruptedException;//	尝试获取锁，如果获取成功则返回true，失败（即锁被其他线程获取）则返回false//	该方法无论如何会立即返回，在拿不到锁时不会一直等待	boolean tryLock();//	超时的获取锁，当前线程在以下3种情况会返回：1.当前线程在超时时间内获得了锁2.当前线程在超时时间内被中断3.超时时间结束，返回false	boolean tryLock(long time,TimeUnit unit) throws InterruptedException;	//释放锁	void unlock();	//获取等待通知组件，该组件和当前的锁绑定，当前线程只有获得了锁，才能调用该组件的wait方法，而调用后，当前线程将释放锁	Condition newCondition();}

通常lock的使用方法

Lock lock=...;	lock.lock();	try{//		处理任务	}catch(Exception ex){			}finally{		lock.unlock();//释放锁	}

tryLock的通常使用

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

lockInterruptibly()必须放在try块中或者声明抛出异常

Lock lock=...;	public void method() throws InterruptedException{		lock.lockInterruptibly();		try{					}finally{			lock.unlock();		}	}

通过Lock接口的Condition newCondition()可以生成一个与当前重入锁绑定的Condition实例，利用Condition对象，我们就可以让线程在何时的时间等待，或者在某一个特定的时刻得到通知，继续执行

Condition是一个接口，提供的基本方法如下：

import java.util.Date;import java.util.concurrent.TimeUnit;public interface Condition {//	使当前线程等待，同时释放当前锁，当其他线程中使用signal或signalAll方法时，线程会重新获得锁并继续执行//	或者当线程被中断时，也能跳出等待	 void await() throws InterruptedException;//	 和await方法基本相同，但并不会在等待过程中响应中断	 void awaitUninterruptibly();	 long awaitNanos(long nanosTimeout) throws InterruptedException;	 boolean await(long time, TimeUnit unit) throws InterruptedException;	 boolean awaitUntil(Date deadline) throws InterruptedException;	 void signal();//唤醒一个在等待中的线程	 void signalAll();//唤醒所有在等待中的线程}

一个例子

package LockTest;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.ReentrantLock;public class LockCondition implements Runnable {	public static ReentrantLock lock=new ReentrantLock();//	通过lock生成一个与之绑定的condition对象	public static Condition condition=lock.newCondition();	public void run(){		try{			lock.lock();			condition.await();//线程在condition对象上进行等待			System.out.println("Thread is going on");		}catch(InterruptedException e){			e.printStackTrace();		}finally{			lock.unlock();		}	}	public static void main(String[] args) throws InterruptedException {		// TODO Auto-generated method stub		LockCondition lc=new LockCondition();		Thread t1=new Thread(lc);		t1.start();		Thread.sleep(2000);//		主线程main发出通知，告诉等待在condition上的线程可以继续执行了		lock.lock();		condition.signal();		lock.unlock();	}}

2.ReentrantLock

即可重入锁，实现了Lock接口，并且提供了更多的方法

//	true表示公平锁，false表示非公平锁	private Lock lock=new ReentrantLock();	public void out3(String str){		lock.lock();//如果有其他线程已经获取锁，那么当前线程在此等待直到其他线程释放锁		try{			for(int i=0;i

就重入锁的实现来看，它主要集中在java层面，在重入锁的实现中，主要包含三个要素：

第一，是原子状态，原子状态使用CAS操作来存储当前锁的状态，判断是否已经被别的线程持有

第二，是等待队列，所有没有请求到锁的线程，会进入等待队列进行等待，待有线程释放锁后，系统就能从等待队列中唤醒一个线程继续工作

第三，是阻塞原语park()和unpark()，用来挂起和恢复线程，没有得到锁的线程将会被挂起

3.ReadWriteLock

ReadWriteLock也是一个接口，在它里面只定义了两个方法

public interface ReadWriteLock {    /**     * Returns the lock used for reading.     *     * @return the lock used for reading     */    Lock readLock();    /**     * Returns the lock used for writing.     *     * @return the lock used for writing     */    Lock writeLock();}

4.ReentrantReadWriteLock

接口ReadWriteLock的一个实现类，提供了很多丰富的方法，最主要的两个:readLock()和writeLock()用来获取读锁和写锁，假如有多个线程要同时进行读操作的话，先看synchronized代码

package LockTest;import java.util.concurrent.locks.ReentrantReadWriteLock;public class lockTest {	private ReentrantReadWriteLock rw=new ReentrantReadWriteLock();	public static void main(String []args){		final lockTest test=new lockTest();		new Thread(){			public void run(){				test.get(Thread.currentThread());			};		}.start();				new Thread(){			public void run(){				test.get(Thread.currentThread());			};		}.start();	}		public synchronized void get(Thread thread){		long start=System.currentTimeMillis();		while(System.currentTimeMillis()-start<=1){			System.out.println(thread.getName()+"正在进行读操作");		}		System.out.println(thread.getName()+"读操作完毕");	}}

运行结果截图，即直到第一个线程执行完读操作后，才会打印第二个线程执行读操作的信息

Thread-0正在进行读操作Thread-0正在进行读操作Thread-0正在进行读操作Thread-0读操作完毕Thread-1正在进行读操作Thread-1正在进行读操作

将上述方法改为读写锁

public void get(Thread thread){		rw.readLock().lock();		try{			long start=System.currentTimeMillis();			while(System.currentTimeMillis()-start<=1){				System.out.println(thread.getName()+"正在进行读操作");			}			System.out.println(thread.getName()+"读操作完毕");		}finally{			rw.readLock().unlock();		}		}

运行结果截图，可见两个线程是同时进行读操作的，这样就大大提升了读操作的效率

Thread-1正在进行读操作Thread-0正在进行读操作Thread-1正在进行读操作Thread-0正在进行读操作Thread-1正在进行读操作Thread-0正在进行读操作Thread-1正在进行读操作Thread-0正在进行读操作

注意：如果有一个线程已经占用了读锁，此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁；如果一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，会一直等待释放写锁

5.提一下信号量Semaphore，允许多个线程同时访问

广义上说，信号量是对锁的扩展，无论是内部锁synchronized还是可重入锁ReentrantLock，一次都只允许一个线程访问一个资源，信号量却是可以指定对个线程，同时访问某一个资源

简单例子，同时开启20个线程，观察输出发现，系统以5个线程为一组，依次输出带有线程ID的提示文本

package LockTest;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Semaphore;public class SemapDemo implements Runnable {	final Semaphore semp=new Semaphore(5);	public void run(){		try{			semp.acquire();//			模拟耗时操作			Thread.sleep(2000);			System.out.println(Thread.currentThread().getId()+":done");			semp.release();//用acquire申请信号量，离开时，务必使用release释放		}catch(InterruptedException e){			e.printStackTrace();		}	}	public static void main(String[] args) {		// TODO Auto-generated method stub		ExecutorService exec=Executors.newFixedThreadPool(20);		final SemapDemo demo=new SemapDemo();		for(int i=0;i<20;i++){			exec.submit(demo);		}	}}

6.Lock和synchronized的选择

（1）Lock是一个接口，而synchronized是java中的关键字，synchronized是内置的语言实现

（2）synchronized在发生异常时会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock（）去释放锁，则很可能造成死锁现象

（3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断

（4）通过Lock可以知道有没有成功获取锁

（5）Lock可以提高多个线程进行读操作的效率

（6）synchronized中的锁是非公平的，ReentrantLock默认也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁

从性能上说，如果竞争资源不激烈，两者是差不多的，而当竞争资源非常激烈（即有大量线程同时竞争），此时Lock的性能远远优于synchronized

参考：http://www.cnblogs.com/dolphin0520/p/3923167.html

转载地址：https://blog.csdn.net/Autumn03/article/details/80853877 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！