lock()/unlock():就是普通的获取锁和释放锁方法,lock()会阻塞直到成功。
lockInterruptibly():与lock()的不同是,它可以响应中断,如果被其他线程中断了,则抛出InterruptedException。
tryLock():只是尝试获取锁,立即返回,不阻塞,如果获取成功,返回true,否则返回false。
tryLock(long time,TimeUnit unit):先尝试获取锁,如果能成功则立即返回true,否则阻塞等待,但等待的最长时间由指定的参数设置,在等待的同时响应中断,如果发生了中断,抛出InterruptedException,如果在等待的时间内获得了锁,返回true,否则返回false。
newCondition:新建一个条件,一个Lock可以关联多个条件
可以看出,相比synchronized,显式锁支持以非阻塞方式获取锁、可以响应中断、可以限时,这使得它灵活得多。
Lock接口的主要实现类是ReentrantLock,它的基本用法lock/unlock实现了与synchronized一样的语义
ReentrantLock有两个构造方法
参数fair表示是否保证公平,不指定的情况下,默认为false,表示不保证公平。所谓公平是指,等待时间最长的线程优先获得锁。保证公平会影响性能,一般也不需要,所以默认不保证,synchronized锁也是不保证公平的
使用显式锁,一定要记得调用unlock。一般而言,应该将lock之后的代码包装到try语句内,在finally语句内释放锁。
public void fun() {
lock.lock();
try{
count++;
}finally {
lock.unlock();
}
}
使用tryLock(),可以避免死锁。在持有一个锁获取另一个锁而获取不到的时候,可以释放已持有的锁,给其他线程获取锁的机会,然后重试获取所有锁。
class Account{
private Lock lock = new ReentrantLock();
private volatile double money;
public Account(double initialMoney){
this.money = initialMoney;
}
public void add(double money){
lock.lock();
try{
this.money = money;
}finally {
lock.unlock();
}
}
public void reduce(double money){
lock.lock();
try{
this.money -= money;
}finally {
lock.unlock();
}
}
public double getMoney() {
return money;
}
public void lock(){
lock.lock();
}
public void unlock(){
lock.unlock();
}
public boolean tryLock(){
return lock.tryLock();
}
}
在账户之间转账,需要两个账户都锁定,如果不使用tryLock,而直接使用lock就会发生死锁。这里可以试一试
class NoEnoughMoney extends Exception {
public static void transfer(Account from,Account to,double money)
throws NoEnoughMoney {
from.lock();
try {
to.lock();
try {
if(from.getMoney() >= money) {
from.reduce(money);
to.add(money);
} else {
throw new NoEnoughMoney();
}
} finally {
to.unlock();
}
} finally {
from.unlock();
}
}
}
public static void simulateDeadLock() {
final int accountNum = 10;
final Account[]accounts = new Account[accountNum];
final Random rnd = new Random();
for(int i = 0; i < accountNum; i++) {
accounts[i]= new Account(rnd.nextInt(10000));
}
int threadNum = 100;
Thread[]threads = new Thread[threadNum];
for(int i = 0; i < threadNum; i++) {
threads[i]= new Thread() {
public void run() {
int loopNum = 100;
for(int k = 0; k < loopNum; k++) {
int i = rnd.nextInt(accountNum);
int j = rnd.nextInt(accountNum);
int money = rnd.nextInt(10);
if(i!= j) {
try {
transfer(accounts[i],accounts[j],money);
} catch (NoEnoughMoney e) {
}
}
}
}
};
threads[i].start();
}
}
这里有10个账户,100个线程,每个线程执行100次循环,在每次循环中,随机挑选两个账户进行转账。每次执行该段代码都会发生死锁。
public static boolean tryTransfer(Account from,Account to,double money) throws NoEnoughMoney {
if(from.tryLock()) {
try {
if(to.tryLock()) {
try {
if(from.getMoney() >= money) {
from.reduce(money);
to.add(money);
} else {
throw new NoEnoughMoney();
}
return true;
} finally {
to.unlock();
}
}
} finally {
from.unlock();
}
}
return false;
}
如果两个锁都能够获得,且转账成功,则返回true,否则返回false。不管怎样,结束都会释放所有锁。
transfer方法可以循环调用该方法以避免死锁
public static void transfer(Account from,Account to,double money) throws NoEnoughMoney {
boolean success = false;
do {
success = tryTransfer(from,to,money);
if(!success) {
Thread.yield();
}
} while (!success);
}
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
发布者:全栈程序员栈长,转载请注明出处:https://javaforall.cn/181684.html原文链接:https://javaforall.cn