1.ReentrantLock
在Java多线程中，可以使用synchronized关键字来实现线程之间的同步互斥。但是在Java 1.5中新增了ReentrantLock类也能达到同样的效果。并且扩展了许多功能。比synchronized更加灵活。
代码演示
新建业务类
public class Business {
private Lock lock = new ReentrantLock();
public void print() {
//lock.lock();
for (int i = 0; i < 5; i++) {
System.out.println(String.format("%s:%d", Thread.currentThread().getName(), i));
}
//lock.unlock();
}
}
- 新建线程A
public class ThreadA extends Thread {
private Business business;
public ThreadA(Business business) {
super();
this.business = business;
}
@Override
public void run() {
business.print();
}
}
- 新建线程B
public class ThreadB extends Thread {
private Business business;
public ThreadB(Business business){
this.business=business;
}
@Override
public void run() {
business.print();
}
}
- Client
public class Client {
public static void main(String[] args) {
Business business = new Business();
ThreadA a = new ThreadA(business);
ThreadB b = new ThreadB(business);
a.start();
b.start();
}
}
- 没加锁的结果
线程B:0
线程B:1
线程B:2
线程B:3
线程B:4
线程A:0
线程A:1
线程A:2
线程A:3
线程A:4
- 加锁后的结果
线程B:0
线程B:1
线程B:2
线程B:3
线程B:4
线程A:0
线程A:1
线程A:2
线程A:3
线程A:4
由此可看出，ReentrantLock实现了synchronized的同步的功能。lock.lock()是获取锁。lock.unlock()是释放锁。
1.1结合Condition实现wait与notify功能
关键字synchronized与wait及notify结合，可以实现等待、通知模式。而ReentrantLock与Condition结合也可以实现同样的功能。
代码演示
新建业务类
public class Business {
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
private int num;
public void print() {
try {
lock.lock();
for (int i = 0; i < 5; i++) {
System.out.println(String.format("%s:%d", Thread.currentThread().getName(), i));
num = i;
if (i == 2){
condition.await();
System.out.println("接受到信号，执行完毕");
}
}
} catch (Exception ex) {
ex.printStackTrace();
} finally {
lock.unlock();
}
}
public void notifyPrint() {
lock.lock();
if (num == 2)
condition.signal();
lock.unlock();
}
}
- 新建线程A
public class ThreadA extends Thread {
private Business business;
public ThreadA(Business business) {
super();
this.business = business;
}
@Override
public void run() {
business.print();
}
}
- 新建线程B
public class ThreadB extends Thread {
private Business business;
public ThreadB(Business business) {
this.business = business;
}
@Override
public void run() {
business.notifyPrint();
}
}
- Client
public class Client {
public static void main(String[] args) throws InterruptedException {
Business business = new Business();
ThreadA a = new ThreadA(business);
a.setName("线程A");
ThreadB b = new ThreadB(business);
b.setName("线程B");
a.start();
Thread.sleep(2000);
b.start();
}
}
- 结果
Connected to the target VM, address: '127.0.0.1:62623', transport: 'socket'
线程A:0
线程A:1
线程A:2
Disconnected from the target VM, address: '127.0.0.1:62623', transport: 'socket'
接受到信号，执行完毕
线程A:3
线程A:4
下面图标表示Object里面的类的方法与Condition类的方法对比
| Object | Condition |
|---|---|
| wait() | await() |
| wait(long timeout) | await(long time, TimeUnit unit) |
| notify() | signal() |
| notifyAll() | signalAll() |
1.2 Condition的部分唤醒
在服务类中创建多个Condition实例。进行对其分组操作。
private Condition condition = lock.newCondition();
private Condition condition2 = lock.newCondition();
1.3公平锁与非公平锁
公平锁：线程获取锁的顺序是按照线程加锁的顺序来分配的。即先进先出的顺序（FIFO）。
非公平锁：获取锁的抢占机制，是随机获得锁的。
- ReentrantLock的构造函数
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
传入true为公平锁，传入false为非公平锁。
1.4ReentrantLock及Condition其他重要方法
- 1.getHoldCount
查询当前线程保持锁定的个数，也就是调用lock()的次数
public int getHoldCount() {
return sync.getHoldCount();
}
- 2.getQueueLength
计算正等待获取此锁定的线程数。比如一个线程在锁内休眠，其他9个线程正在等待，那么调用此方法返回9。
public final int getQueueLength() {
return sync.getQueueLength();
}
- 3.getWaitQueueLength
返回给定条件的Condition相关的等待此锁的线程数。
public int getWaitQueueLength(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
}
- 4.hasQueuedThread
查询指定的线程是否正在等待获取此锁
public final boolean hasQueuedThread(Thread thread) {
return sync.isQueued(thread);
}
- 5.hasQueuedThreads
查询是否有线程正在等待获取此锁
public final boolean hasQueuedThreads() {
return sync.hasQueuedThreads();
}
- 6.hasWaiters
根据Condition条件去查询是否有线程正在等待获取此锁
public boolean hasWaiters(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
}
- 7.isFair
判断是不是公平锁
public final boolean isFair() {
return sync instanceof FairSync;
}
- 8.isHeldByCurrentThread
查询当前是否保持锁定
public boolean isHeldByCurrentThread() {
return sync.isHeldExclusively();
}
- 9.isLocked
判断当前锁是否由任意线程锁定
public boolean isLocked() {
return sync.isLocked();
}
- 10.lockInterruptibly
如果当前线程未被中断，则获取获取锁定，（相当于lock()）如果已经中断则抛出异常
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
- 11.tryLock
当锁没有被其他线程占用，则获取锁定。
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
- 12.tryLock(long timeout, TimeUnit unit)
在给定的时间内，锁没有被其他线程占用，则获取锁
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
- 13.awaitUninterruptibly
线程在等待的时候，线程若主动抛出异常，则相对应的程序也不会抛出异常。
public final void awaitUninterruptibly() {
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
boolean interrupted = false;
while (!isOnSyncQueue(node)) {
LockSupport.park(this);
if (Thread.interrupted())
interrupted = true;
}
if (acquireQueued(node, savedState) || interrupted)
selfInterrupt();
}
- 14.awaitUntil
某线程在指定的时间内处于等待状态，超过时间，自动运行线程。
public final boolean awaitUntil(Date deadline)
throws InterruptedException {
long abstime = deadline.getTime();
if (Thread.interrupted())
throw new InterruptedException();
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
boolean timedout = false;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
if (System.currentTimeMillis() > abstime) {
timedout = transferAfterCancelledWait(node);
break;
}
LockSupport.parkUntil(this, abstime);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null)
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
return !timedout;
}
2.ReentrantReadWriteLock
ReentrantLock具有完全互斥排他的效果，即同一时间只有一个线程在执行ReentrantLock.Lock()方法后面的任务。
这样虽然保证了实例变量的线程安全性，但是效率却是低下的。这时候就诞生了读写锁ReentrantReadWriteLock。
读写锁有两个锁：
- 1.共享锁：读操作相关的锁
- 2.排他锁：写操作相关的锁
private ReentrantReadWriteLock lock1 = new ReentrantReadWriteLock();
lock1.writeLock().lock();
lock1.writeLock().unlock();
lock1.readLock().lock();
lock1.readLock().unlock();
同一个类中，有两个及两个以上的方法。一个使用读锁，一个使用写锁。那么它们是互斥的。只有所有的方法是读锁，才是不相互干扰，不排斥的。
