LOCK接口

Lock接口

java中提供了两种不同的方式加锁，synchronized和juc包下的Lock接口。
Lock是java 1.5中引入的线程同步工具，它主要用于多线程下共享资源的控制。
        - 需要用户主动释放锁

        - 可中断，设置超时中断
        - 默认也是非公平锁，可以设置成公平锁
        - 锁绑定多个condition用来精确唤醒

常见方法

void lock();尝试获取锁，获取成功则返回，否则阻塞当前线程
void lockInterruptibly() throws InterruptedException;尝试获取锁，线程在成功获取锁之前被中断，则放弃获取锁，抛出异常
boolean tryLock();尝试获取锁，获取锁成功则返回true，否则返回false
boolean tryLock(long time, TimeUnit unit)尝试获取锁，若在规定时间内获取到锁，则返回true，否则返回false，未获取锁之前被中断，则抛出异常
void unlock();释放锁，一般需要使用try/finally结构保证锁的释放

 Lock的基本使用

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
//Lock的基本使用
public class Test1 {
	public static void main(String[] args) {
		NumOperation no=new NumOperation();
		//启动8个线程，一个线程执行50次加，一个线程执行50次减
		Thread[] th=new Thread[8];
		for(int k=0;k<4;k++) {
			th[k*2]=new Thread(()->{
				for(int i=0;i<50;i++) {
					no.add();
				}
			});
			th[k*2].start();
			th[k*2+1]=new Thread(()->{
				for(int i=0;i<50;i++) {
					no.sub();
				}
			});
			th[k*2+1].start();
		}
		for(Thread tmp:th)
			if(tmp!=null)
				try {
					tmp.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
		System.out.println("Main:"+no.getNum());
	}
}
 
 
class NumOperation{
	private Long num=0L;//共享数据
	//这里的静态特性用于保证锁只有一个
	private static final Lock lock=new ReentrantLock();// 重入锁，是Lock接口的一个实现
	
	public void add() {
		lock.lock();//申请锁，获取不到锁则会阻塞
		try {
		System.out.println(Thread.currentThread()+"开始加操作"+num);
		num++;
		System.out.println(Thread.currentThread()+"开始减操作"+num);
		}finally {
			lock.unlock();//释放锁，lock允许重入，但是必须保证申请和释放次数相等
		}
	}
	public void sub() {
		lock.lock();
		try {
		System.out.println(Thread.currentThread()+"开始加操作"+num);
		num--;
		System.out.println(Thread.currentThread()+"开始减操作"+num);
		}finally {
			lock.unlock();
		}
	}
	
	public Long getNum() {
		return num;
	}
}

Lock的实现类

Lock有三个实现类，一个是ReentrantLock，另两个是ReentrantReadWriteLock类中的两个静态内部类ReadLock和WriteLock。这些类的底层使用都依赖于juc包抽象队列同步器AbstractQueuedSynchronizer

使用方法：多线程下访问（互斥）共享资源时， 访问前加锁，访问结束以后解锁，解锁的操作推荐放入finally块中。

private static final ReentrantLock lock=new ReentrantLock();  定义锁对象

在具体方法中
lock.lock();  
try{
       代码块;
}finally{
        lock.unlock();
}

Codition接口

Condition接口是一个可以带条件的线程通知接口，需要和Lock锁一起使用，用于实现比Object类种线程通知方法更精细的控制  wait/notify/notifyAll

方法：
        await()类似于Object种的wait方法
        signal()类似于Object中的notify方法

应用场景：线程如果不满足某个Condition将被暂停挂起，而等到线程满足条件时被唤醒

有5个线程输出A，有5个线程输出B，需要实现输出ABABAB...

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test3 {
	public static void main(String[] args) {
		OutResource or=new OutResource();
		for(int i=0;i<5;i++) {
			new Thread(()->{
				for(int k=0;k<5;k++) {
					or.printA();
				}
			}).start();
			;
			new Thread(()->{
				for(int k=0;k<5;k++) {
					or.printB();
				}
			}).start();
		}
	}
}
 
class OutResource{
	private static final Lock lock=new ReentrantLock();
	private static final Condition acon=lock.newCondition();
	private static final Condition bcon=lock.newCondition();
	private volatile boolean isA=false;
	
	public void printA() {
		lock.lock();
		try {
			while(isA) {
				try {
					acon.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("A"+Thread.currentThread().getName()+" ");
			isA=true;
			bcon.signalAll();
		}finally {
			lock.unlock();
		}
	}
	public void printB() {
		lock.lock();
		try {
			while(!isA) {
				try {
					bcon.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("B"+Thread.currentThread().getName()+" ");
			isA=true;
			acon.signalAll();
		}finally {
			lock.unlock();
		}
	}
}

Lock接口的具体实现类ReentrantLock

Lock接口
实现类ReentrantLock，区分读写ReadWriteLock接口
        -tryLock
        -lock

具体实现类ReentrantLock
实现了Lock接口
         - newCondition创建一个条件对象，用来管理得到锁但是不能执行工作的线程

如果一个线程lock.lock()已经获取了锁，也可以多次调用这个方法(重入锁名称的来源)，都可以获取到锁，但是获取多少次锁必须通过lock.unlock释放多少次，否则其它线程会阻塞在lock.lock()方法上，注意lock()方法和unlock()方法的执行次数必须匹配，所以一般建议使用lock.lock();
try{}finally{lock.unlock();}
 
当调用condition.await()阻塞线程时会自动释放锁，不管调用了多少次lock.lock()，这时阻塞在lock.lock()方法上线程则可以获取锁

当调用condition.signal()唤醒线程时会继续上次阻塞的位置继续执行,默认会自动重新获取锁(注意和阻塞时获取锁的次数一致)

ReentrantReadWriteLock是Lock的另一种实现方式，ReentrantLock是一个排他锁，同一时间只允许一个线程访问，而ReentrantReadWriteLock允许多个读线程同时访问，但不允许写线程和读线程、写线程和写线程同时访问。相对于排他锁，提高了并发性。在实际应用中，大部分情况下对共享数据（如缓存）的访问都是读操作远多于写操作，这时ReentrantReadWriteLock能够提供比排他锁更好的并发性和吞吐量。

ReentrantLock的底层实现

底层实现依赖于Sync实现，Sync是AbstractQueuedSynchronizer的抽象子类。在ReentrantLock有两个静态内部类NonfairSync和FairSync

public ReentrantLock() {
     sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
     sync = fair ? new FairSync() : new NonfairSync();
}
    
ReentrantLock提供了很多额外的方法，例如isFair()可以判断是否为公平锁isLocked判断锁是否被任何线程获取了，isHeldByCurrentThread判断锁是否被当前线程获取，hasQueuedThreads()判断是否有线程在等待该锁
    
 ReadWriteLock接口
实例上和Lock接口无关，提供了通过分开读锁和写锁，控制锁阻塞的方法，提高程序的执行效率

public interface ReadWriteLock {
    Lock readLock();用于获取读锁，读锁之间不相互阻塞
    Lock writeLock();用于获取写锁，写锁和其它锁互斥
}
    
    功能在于将文件的读写操作分开，分成2个锁分配给线程，从而实现多个线程可以同时执行读操作

    实现类ReentrantReadWriteLock
    提供了写锁和读锁的实现

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Test1 {
	private static final ReadWriteLock lock = new ReentrantReadWriteLock();
 
	public void get() {
		lock.readLock();// 获取读锁
		try {
			long start = System.currentTimeMillis();
			while (System.currentTimeMillis() - start <= 1) {
				System.out.println(Thread.currentThread() + "正在进行读操作......");
			}
			System.out.println(Thread.currentThread() + "读取操作完毕");
		} finally {
			lock.readLock().unlock();
		}
	}
 
	public void put() {
		lock.writeLock();// 获取读锁
		try {
			long start = System.currentTimeMillis();
			while (System.currentTimeMillis() - start <= 1) {
				System.out.println(Thread.currentThread() + "正在进行写操作......");
			}
			System.out.println(Thread.currentThread() + "写出操作完毕");
		} finally {
			lock.writeLock().unlock();
		}
	}
 
	public static void main(String[] args) {
		Test1 t1 = new Test1();
		for (int i = 0; i < 5; i++) {
			int k = i;
			new Thread(() -> {
				if (k % 2 == 0)
					t1.get();
				else
					t1.put();
			}).start();
		}
	}
}