欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

Lock

程序员文章站 2022-03-09 18:58:08
...

一，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<str.length();i++){
				System.out.println(str.charAt(i));
			}
			System.out.println();
		}finally{
//			释放锁资源，之所以加入try代码块，是为了保证锁资源的释放
//			如果代码发生异常也可以保证锁资源的释放，否则其他线程无法拿到锁资源执行业务逻辑，永远处于等待状态
			lock.unlock();
		}
	}

就重入锁的实现来看，它主要集中在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

相关标签： Lock

上一篇： @ConfigurationProperties配合@PropertySource进行配置文件数据注入

下一篇： JUC-6.同步锁Lock

推荐阅读