1.
* 使用ReentrantLock可以代替Synchronized
* 需注意:必须手动释放锁(重要!!!!)
* 使用synchronized如果遇到异常,jvm会自动释放锁
* 当时lock会手动释放锁,因此经常在finally中进行锁的释放
2.
* 与Synchronized区别:
* 使用ReentrantLock可以进行尝试锁定 tryLock()
* 这样无法锁定,或者在指定时间内无法锁定,线程可以决定是否继续等待
*3
* 使用ReentrantLock可以调用lockInterruptibly方法,可以对线程interrupt方法做出响应
*4.
*RetrantLock还可以指定为公平锁 即等的时间长 先占有锁;效率低!
* Synchronized默认为非公平锁 看线程调度器 即竞争锁 效率高!
package reentrantlock_test;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 使用ReentrantLock可以代替Synchronized
* 需注意:必须手动释放锁(重要!!!!)
* 使用synchronized如果遇到异常,jvm会自动释放锁
* 当时lock会手动释放锁,因此经常在finally中进行锁的释放
* @author x1c
*
*/
public class ReentrantLock1 {
Lock lock = new ReentrantLock(); //Lock java.util.concurrent.locks.Lock
void m1() {
lock.lock(); //synchronized(this)
try {
for (int i = 0; i < 10; i++) {
TimeUnit.SECONDS.sleep(1);
System.out.println(i);
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock(); //必须手动释放锁!!!
}
}
void m2() {
lock.lock();
System.out.println("m2===");
lock.unlock();
}
public static void main(String[] args) {
ReentrantLock1 rl = new ReentrantLock1();
new Thread(rl::m1).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(rl::m2).start();
}
}
3.
package reentrantlock_test;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 使用ReentrantLock可以代替Synchronized
* 需注意:必须手动释放锁(重要!!!!)
* 使用synchronized如果遇到异常,jvm会自动释放锁
* 当时lock会手动释放锁,因此经常在finally中进行锁的释放
* -------------------------
* 与Synchronized区别:
* 使用ReentrantLock可以进行尝试锁定 tryLock()
* 这样无法锁定,或者在指定时间内无法锁定,线程可以决定是否继续等待
* @author x1c
*
*/
public class ReentrantLock2 {
Lock lock = new ReentrantLock(); //Lock java.util.concurrent.locks.Lock
void m1() {
lock.lock(); //synchronized(this)
try {
for (int i = 0; i < 10; i++) {
TimeUnit.SECONDS.sleep(1);
System.out.println(i);
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock(); //必须手动释放锁!!!
}
}
void m2() {
/*
// lock.lock();
boolean locked = lock.tryLock(); //尝试锁定
System.out.println("m2===");
// lock.unlock();
if (locked) {
lock.unlock();
}
*/
boolean locked = false;
try {
locked = lock.tryLock(5, TimeUnit.SECONDS);//参数:时间数值+单位 boolean java.util.concurrent.locks.Lock.tryLock(long time, TimeUnit unit) throws InterruptedException
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (locked) {
lock.unlock();
}
}
}
public static void main(String[] args) {
ReentrantLock2 rl = new ReentrantLock2();
new Thread(rl::m1).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(rl::m2).start();
}
}
3.
package reentrantlock_test;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 1
* 使用ReentrantLock可以代替Synchronized
* 需注意:必须手动释放锁(重要!!!!)
* 使用synchronized如果遇到异常,jvm会自动释放锁
* 当时lock会手动释放锁,因此经常在finally中进行锁的释放
* -------------------------
* 2
* 与Synchronized区别:
* 使用ReentrantLock可以进行尝试锁定 tryLock()
* 这样无法锁定,或者在指定时间内无法锁定,线程可以决定是否继续等待
*---------------------------
*3
* 使用ReentrantLock可以调用lockInterruptibly方法,可以对线程interrupt方法做出响应
*
*/
public class ReentrantLock3 {
public static void main(String[] args) {
Lock lock = new ReentrantLock(); //Lock java.util.concurrent.locks.Lock
Thread t1 = new Thread(()->{
lock.lock(); //synchronized(this)
try {
System.out.println("t1.start");
TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
System.out.println("t1.end");
} catch (InterruptedException e) {
System.out.println("interrupted!!!!");
}finally {
lock.unlock(); //必须手动释放锁!!!
}
});
t1.start();
Thread t2 = new Thread(()->{
try {
// lock.lock();
lock.lockInterruptibly(); //可以对interruptible做出响应
System.out.println("t2.start");
TimeUnit.SECONDS.sleep(5);
System.out.println("t2.end");
} catch (InterruptedException e) {
System.out.println("2-interrupted-1!!!!");
} finally {
if (lock.tryLock()) {
lock.unlock();
}
}
});
t2.start(); //线程启动
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.interrupt(); //线程打断
}
}
4.
package reentrantlock_test;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 1
* 使用ReentrantLock可以代替Synchronized
* 需注意:必须手动释放锁(重要!!!!)
* 使用synchronized如果遇到异常,jvm会自动释放锁
* 当时lock会手动释放锁,因此经常在finally中进行锁的释放
* -------------------------
* 2
* 与Synchronized区别:
* 使用ReentrantLock可以进行尝试锁定 tryLock()
* 这样无法锁定,或者在指定时间内无法锁定,线程可以决定是否继续等待
*---------------------------
*3
* 使用ReentrantLock可以调用lockInterruptibly方法,可以对线程interrupt方法做出响应
*
*4.
*RetrantLock还可以指定为公平锁 即等的时间长 先占有锁;效率低!
* Synchronized默认为非公平锁 看线程调度器 即竞争锁 效率高!
*
*/
public class ReentrantLock4 extends Thread{
private static ReentrantLock lock = new ReentrantLock(true); //参数为true表示公平java.util.concurrent.locks.ReentrantLock.ReentrantLock(boolean fair)
@Override
public void run() {
for (int i = 0; i < 10; i++) {
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+"获得锁");
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) {
ReentrantLock4 rl = new ReentrantLock4();
Thread th1 = new Thread(rl);// java.lang.Thread.Thread(Runnable target)
Thread th2 = new Thread(rl);
th1.start();
th2.start();
}
}