Java并发编程之Lock

最新推荐文章于 2024-05-27 09:49:55 发布

风清扬_gyx

最新推荐文章于 2024-05-27 09:49:55 发布

阅读量281

点赞数

分类专栏： Java并发编程文章标签： JAVA 并发多线程

本文链接：https://blog.csdn.net/gyx_2110/article/details/78114687

版权

Java并发编程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、Lock是什么？

从Java 5之后，在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问，那就是Lock，它是java.util.concurrent.locks包中的一个接口。

也许有朋友会问，既然都可以通过synchronized来实现同步访问了，那么为什么还需要提供Lock呢？

二、Lock及其实现类的用法

下面我们就来探讨一下java.util.concurrent.locks包中常用的类和接口。

1、lock

首先要说明的就是Lock，通过查看Lock的源码可知，Lock是一个接口：

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

Lock接口方法的使用：

lock()、tryLock()、tryLock(long time, TimeUnit unit)、lockInterruptibly()都是用来获取锁的。

unLock() 方法是用来释放锁的。

四个获取锁方法的区别：

◆lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在t ry{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

◆tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

◆tryLock(longtime, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

◆lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。

2、ReentrantLock

ReentrantLock，意思是“可重入锁”，ReentrantLock是实现了Lock接口的类，并且ReentrantLock提供了更多的方法。

下面通过一些实例看具体看一下如何使用ReentrantLock。

实例一:

package com.gyx.locktest;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyLockTest {
	static Lock lock = new ReentrantLock();

	public static void main(String[] args) {
		MyLockTest.MyThread thread1 = new MyLockTest().new MyThread();
		MyLockTest.MyThread thread2 = new MyLockTest().new MyThread();
		thread1.start();
		thread2.start();
	}

	class MyThread extends Thread {
		@Override
		public void run() {
			Thread thread = Thread.currentThread();
			lock.lock(); // 得到锁
			try {
				System.out.println(thread.getName() + "得到了锁");
			} catch (Exception e) {
			} finally {
				System.out.println(thread.getName() + "释放了锁");
				lock.unlock(); // 释放锁
			}
		}
	}
}

实例二:

package com.gyx.locktest;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyLockTest {
	static Lock lock = new ReentrantLock();

	public static void main(String[] args) {
		MyLockTest.MyThread thread1 = new MyLockTest().new MyThread();
		MyLockTest.MyThread thread2 = new MyLockTest().new MyThread();
		thread1.start();
		thread2.start();
	}

	class MyThread extends Thread {
		@Override
		public void run() {
			Thread thread = Thread.currentThread();
			boolean tryLock = lock.tryLock(); // 尝试得到锁
			if (tryLock) {
				try {
					System.out.println(thread.getName() + "得到了锁");
				} catch (Exception e) {
				} finally {
					System.out.println(thread.getName() + "释放了锁");
					lock.unlock(); // 释放锁
				}
			} else {
				System.out.println(thread.getName() + "尝试获得锁失败");
			}
		}
	}
}

实例三:

package com.gyx.locktest;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import org.apache.activemq.broker.InsertableMutableBrokerFilter;

public class MyLockTest {
	static Lock lock = new ReentrantLock();

	public static void main(String[] args) {
		MyLockTest.MyThread thread1 = new MyLockTest().new MyThread();
		MyLockTest.MyThread thread2 = new MyLockTest().new MyThread();
		thread1.start();
		thread2.start();
		// 为了让线程1获得锁这里使当前线程进行睡眠
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		thread2.interrupt();
	}

	public void insert(Thread thread) throws InterruptedException {
		lock.lockInterruptibly();
		try {
			System.out.println(thread.getName() + "得到了锁");
			long startTime = System.currentTimeMillis();
			for (;;) {
				// 得到锁的线程执行三秒
				if (System.currentTimeMillis() - startTime >= 3000)
					break;
			}
		} finally {
			System.out.println(Thread.currentThread().getName() + "执行finally");
			lock.unlock();
			System.out.println(thread.getName() + "释放了锁");
		}
	}

	class MyThread extends Thread {
		@Override
		public void run() {
			try {
				insert(Thread.currentThread());
			} catch (InterruptedException e) {
				System.out.println(Thread.currentThread().getName() + "被中断");
			}
		}
	}
}

3、ReentrantReadWriteLock

读写锁 ReadWriteLock读写锁维护了一对相关的锁，一个用于只读操作，一个用于写入操作。

读写锁的作用:

◆使用读写锁，可以实现读写分离锁定，读操作并发进行，写操作只允许单个线程

◆如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。

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

以下是读写锁的一个实例:

package com.gyx.locktest;

import java.util.Random;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockTest {
	public static void main(String[] args) {
		final ReadWriteHandle rwh = new ReadWriteHandle();
		for (int i = 0; i < 3; i++) {
			new Thread() {
				public void run() {
					while (true) { rwh.put(new Random().nextInt(10000)); }
				}

			}.start();
			
			new Thread() {
				public void run() {
					while (true) { rwh.get(); }
				}
			}.start();
		}
	}
}

class ReadWriteHandle {
	private Object data = 1000;
	private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

	public void get() {
		rwl.readLock().lock(); // 上读锁
		try {
			Thread.sleep(500);
			System.out.println(Thread.currentThread().getName() + "准备读数据!");
			System.out.println(Thread.currentThread().getName() + "读到数据:"
					+ data);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			rwl.readLock().unlock();
		}
	}

	public void put(Object data) {

		rwl.writeLock().lock(); // 上写锁
		try {
			System.out.println(Thread.currentThread().getName() + "准备写数据!");
			Thread.sleep(500);
			this.data = data;
			System.out.println(Thread.currentThread().getName() + "写入数据:"
					+ data);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			rwl.writeLock().unlock();
		}
	}
}

三、Lock和synchronized的选择

总结来说，Lock和synchronized有以下几点不同： 1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
5）Lock可以提高多个线程进行读操作的效率。
在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。