ReentrantLock是jdk1.5里面的， 可以理解为相当于 Synchronized，但二者实现机制不一样，总之是 加锁，同步代码
下面看一个示例
public class Test {
Lock lock = new ReentrantLock();
void m1() {
try {
lock.lock(); //加锁
for (int i = 0; i < 10; i++) {
System.out.println("m1() - " + i);
TimeUnit.SECONDS.sleep(1);
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock(); //释放锁
}
}
void m2() {
lock.lock(); //加锁
System.out.println("m2()");
lock.unlock(); //释放锁
}
public static void main(String[] args) {
final Test t = new Test();
new Thread(new Runnable() {
@Override
public void run() {
t.m1();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
t.m2();
}
}).start();
//运行后可以看到 m1() 先打印10次 在打印没m2()
//lock.lock() 到 lock.unlock() 之间的代码是同步的
}
}
尝试锁
直接上代码 注释在代码中
public class Test {
Lock lock = new ReentrantLock();
void m1() {
lock.lock();
for (int i = 0; i < 10; i++) {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("m1() - "+i);
}
lock.unlock();
}
void m2() {
//尝试锁，尝试去获取锁
boolean isLocked = false;
try {
//尝试锁， 如果有锁，无法获取锁标记，返回false。
//如果获取锁标记，返回true
//isLocked = lock.tryLock();
// 阻塞尝试锁，阻塞参数代表的时长，尝试获取锁标记。
// 如果超时，不等待。直接返回。
//这里表示在5秒 内去尝试获取锁，如果能获取到返回true,否则返回false
isLocked = lock.tryLock(5, TimeUnit.SECONDS);
if(isLocked) {
System.out.println("m2() is synchronized");
}else {
System.out.println("m2() is unSynchronized");
}
} catch (Exception e) {
e.printStackTrace();
}finally {
if(isLocked) {
// 尝试锁在解除锁标记的时候，一定要判断是否获取到锁标记。
// 如果当前线程没有获取到锁标记，会抛出异常。
//就是说 这里的if判断有必要写一下
lock.unlock();
}
}
}
public static void main(String[] args) {
Test t = new Test();
new Thread(new Runnable() {
@Override
public void run() {
t.m1();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
t.m2();
}
}).start();
}
}
可打断
阻塞状态： 包括普通阻塞，等待队列，锁池队列。
- 普通阻塞： sleep(10000)， 可以被打断。调用thread.interrupt()方法，可以打断阻塞状态，抛出InterruptedException异常。
- 等待队列： wait()方法被调用，也是一种阻塞状态，只能由notify唤醒。无法打断
- 锁池队列： 无法获取锁标记。不是所有的锁池队列都可被打断。
①使用ReentrantLock的lock方法，获取锁标记的时候，如果需要阻塞等待锁标记，无法被打断。
②使用ReentrantLock的lockInterruptibly方法，获取锁标记的时候，如果需要阻塞等待，可以被打断，打断后抛出InterruptedException异常。
下面看一段代码
public class Test {
Lock lock = new ReentrantLock();
void m1() {
lock.lock();
for (int i = 0; i < 5; i++) { //循环5次 每一秒 打印一下
try {
TimeUnit.SECONDS.sleep(1);
System.out.println("m1() - "+ i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
void m2() {
try {
//也是加锁 但是 可尝试打断,阻塞等待锁。可以被其他的线程打断阻塞状态
lock.lockInterruptibly();
//lock.lock();
System.out.println("m2()");
} catch (InterruptedException e) {
//被其他的线程打断后 进入到这个异常
System.out.println("m2() interrupted");
}finally {
try{
//如果没有锁的话，执行lock.unlock(); 会抛出异常
lock.unlock();
}catch(Exception e){
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Test t = new Test();
new Thread(new Runnable() { //
@Override
public void run() {
t.m1();
}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//2秒后 启动t2线程
Thread t2 = new Thread(new Runnable() { //t2线程
@Override
public void run() {
t.m2();
}
});
t2.start();
//打断 。 非正常结束阻塞状态的线程，都会抛出异常。
//如果m2() 中第一行 换成lock.lock(); 则不会抛出异常
t2.interrupt();
}
}
公平锁
一般来说 多个线程去获取一把锁是属于竞争关系的，不管等的时间有多久。
比如 t1 先获取到了锁，在运行阶段，t2，t3，t4都在阻塞等待，当t1释放锁后，那么t2，t3，t4回去竞争 那把锁，这个是随机的 ，不管哪个线程等的多久
ReentrantLock 可以实现公平锁，实现等待时间长的线程先执行
Synchronized没有公平性
//定义公平锁 就是 加上 参数 true
Lock lock = new ReentrantLock(true);
这种比如 斗地主的 轮询等待时间
ReentrantLock生产者 消费者 Condition
public class Test<E> {
private final LinkedList<E> list = new LinkedList<>();
private final int MAX = 10;
private int count = 0;
private Lock lock = new ReentrantLock();
private Condition producer = lock.newCondition();
private Condition consumer = lock.newCondition();
public int getCount(){
return count;
}
public void put(E e){
lock.lock();
try {
while(list.size() == MAX){
System.out.println(Thread.currentThread().getName() + " 等待。。。");
// 进入等待队列。释放锁标记。
// 借助条件，进入的等待队列。
producer.await();
}
System.out.println(Thread.currentThread().getName() + " put 。。。");
list.add(e);
count++;
// 借助条件，唤醒所有的消费者。
consumer.signalAll();
} catch (InterruptedException e1) {
e1.printStackTrace();
} finally {
lock.unlock();
}
}
public E get(){
E e = null;
lock.lock();
try {
while(list.size() == 0){
System.out.println(Thread.currentThread().getName() + " 等待。。。");
// 借助条件，消费者进入等待队列
consumer.await();
}
System.out.println(Thread.currentThread().getName() + " get 。。。");
e = list.removeFirst();
count--;
// 借助条件，唤醒所有的生产者
producer.signalAll();
} catch (InterruptedException e1) {
e1.printStackTrace();
} finally {
lock.unlock();
}
return e;
}
public static void main(String[] args) {
final Test<String> c = new Test<>();
for(int i = 0; i < 10; i++){
new Thread(new Runnable() {
@Override
public void run() {
for(int j = 0; j < 5; j++){
System.out.println(c.get());
}
}
}, "consumer"+i).start();
}
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
for(int i = 0; i < 2; i++){
new Thread(new Runnable() {
@Override
public void run() {
for(int j = 0; j < 25; j++){
c.put("container value " + j);
}
}
}, "producer"+i).start();
}
}
}
最后
1，重入锁ReentrantLock,建议应用的同步方式，相对效率比synchronized高，量级较轻
2，synchronized在jdk1.5开始尝试优化，到1.7版本级之后 效率已经非常好了，在绝对效率上 不比synchronized差多少
3，使重入锁 ，必须手工释放锁标记，一般在finally中释放（unlock()方法）
