代码示例:
public class GetLockDemo {
// 公平锁 // static Lock lock =new ReentrantLock(true);
// 非公平锁 static Lock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
// 主线程 拿到锁 lock.lock();
Thread thread =
new Thread(
() -> {
// 子线程 获取锁(不死不休) System.out.println("begain to get lock...");
lock.lock();
System.out.println("succeed to get lock...");
// // 子线程 获取锁(浅尝辄止)
// boolean result = lock.tryLock();
// System.out.println("是否获得到锁:" + result);
//
// // 子线程 获取锁(过时不候)
// try {
// boolean result1 = lock.tryLock(5, TimeUnit.SECONDS);
// System.out.println("是否获得到锁:" + result1);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
//
// // 子线程 获取锁(任人摆布) // try {
// System.out.println("start to get lock Interruptibly");
// lock.lockInterruptibly();
// } catch (InterruptedException e) {
// e.printStackTrace();
// System.out.println("dad asked me to stop...");
// }
});
thread.start();
Thread.sleep(10000L);
lock.unlock();
}
}
结论:
condition代码示例:
public class ConditionDemo {
static Lock lock = new ReentrantLock();
static Condition condition = lock.newCondition();
public static void main(String[] args) throws InterruptedException {
Thread thread =
new Thread(
() -> {
lock.lock();
System.out.println("condition.await()");
try {
condition.await();
System.out.println("here i am...");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
});
thread.start();
Thread.sleep(2000L);
lock.lock();
condition.signalAll();
lock.unlock();
}
}
ReentrantLock是可重入锁,同一线程可以多次获取到锁
手动实现ReentrantLock代码示例:
public class MyReentrantLock implements Lock {
// 标记重入次数的count值 private AtomicInteger count = new AtomicInteger(0);
// 锁的拥有者 private AtomicReference<Thread> owner = new AtomicReference<>();
// 等待队列 private LinkedBlockingDeque<Thread> waiters = new LinkedBlockingDeque<>();
@Override
public boolean tryLock() {
// 判断count是否为0,若count!=0,说明锁被占用 int ct = count.get();
if (ct != 0) {
// 判断锁是否被当前线程占用,若被当前线程占用,做重入操作,count+=1
if (owner.get() == Thread.currentThread()) {
count.set(ct + 1);
return true;
} else {
// 若不是当前线程占用,互斥,抢锁失败,return false
return false;
}
} else {
// 若count=0, 说明锁未被占用,通过CAS(0,1) 来抢锁 if (count.compareAndSet(ct, ct + 1)) {
// 若抢锁成功,设置owner为当前线程的引用 owner.set(Thread.currentThread());
return true;
} else {
return false;
}
}
}
@Override
public void lock() {
// 尝试抢锁 if (!tryLock()) {
// 如果失败,进入等待队列 waiters.offer(Thread.currentThread());
// 自旋 for (; ; ) {
// 判断是否是队列头部,如果是 Thread head = waiters.peek();
if (head == Thread.currentThread()) {
// 再次尝试抢锁 if (!tryLock()) {
// 若抢锁失败,挂起线程,继续等待 LockSupport.park();
} else {
// 若成功,就出队列 waiters.poll();
return;
}
} else {
// 如果不是队列头部,就挂起线程 LockSupport.park();
}
}
}
}
public boolean tryUnlock() {
// 判断,是否是当前线程占有锁,若不是,抛异常 if (owner.get() != Thread.currentThread()) {
throw new IllegalMonitorStateException();
} else {
// 如果是,就将count-1 若count变为0 ,则解锁成功 int ct = count.get();
int nextc = ct - 1;
count.set(nextc);
// 判断count值是否为0
if (nextc == 0) {
owner.compareAndSet(Thread.currentThread(), null);
return true;
} else {
return false;
}
}
}
@Override
public void unlock() {
// 尝试释放锁 if (tryUnlock()) {
// 获取队列头部, 如果不为null则将其唤醒 Thread thread = waiters.peek();
if (thread != null) {
LockSupport.unpark(thread);
}
}
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public void lockInterruptibly() throws InterruptedException {}
@Override
public Condition newCondition() {
return null;
}
}
synchronized: 优点:
Lock:
优点:可以实现synchronized无法实现的锁的高级功能如公平锁,读写锁等,同时还可以实现更多的功能 缺点:需手动释放锁unlock,使用不当容易造成死锁
结论: 两者都是可重入锁,synchronized可以类比为傻瓜相机,提供了固定的功能,而Lock可以类比为单方,可以根据需要调节所需的功能
本文分享自 Coding Diary 微信公众号,前往查看
如有侵权,请联系 cloudcommunity@tencent.com 删除。
本文参与 腾讯云自媒体同步曝光计划 ,欢迎热爱写作的你一起参与!