标签：even Java val lock ReentrantLock old 线程 原理 public
考虑一个场景，轮流打印0-100以内的技术和偶数。通过使用 synchronize 的 wait，notify机制就可以实现，核心思路如下：
使用两个线程，一个打印奇数，一个打印偶数。这两个线程会共享一个数据，数据每次自增，当打印奇数的线程发现当前要打印的数字不是奇数时，执行等待，否则打印奇数，并将数字自增1，对于打印偶数的线程也是如此
//打印奇数的线程
//打印奇数的线程
private static class OldRunner implements Runnable{
private MyNumber n;
public OldRunner(MyNumber n) {
this.n = n;
}
public void run() {
while (true){
n.waitToOld(); //等待数据变成奇数
System.out.println("old:" + n.getVal());
n.increase();
if (n.getVal()>98){
break;
}
}
}
}
//打印偶数的线程
private static class EvenRunner implements Runnable{
private MyNumber n;
public EvenRunner(MyNumber n) {
this.n = n;
}
public void run() {
while (true){
n.waitToEven(); //等待数据变成偶数
System.out.println("even:"+n.getVal());
n.increase();
if (n.getVal()>99){
break;
}
}
}
}
共享的数据如下
private static class MyNumber{
private int val;
public MyNumber(int val) {
this.val = val;
}
public int getVal() {
return val;
}
public synchronized void increase(){
val++;
notify(); //数据变了，唤醒另外的线程
}
public synchronized void waitToOld(){
while ((val % 2)==0){
try {
System.out.println("i am "+Thread.currentThread().getName()+" ,but now is even:"+val+",so wait");
wait(); //只要是偶数，一直等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void waitToEven(){
while ((val % 2)!=0){
try {
System.out.println("i am "+Thread.currentThread().getName()+" ,but now old:"+val+",so wait");
wait(); //只要是奇数，一直等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
运行代码如下
MyNumber n = new MyNumber(0); Thread old=new Thread(new OldRunner(n),"old-thread"); Thread even = new Thread(new EvenRunner(n),"even-thread"); old.start(); even.start();
运行结果如下
i am old-thread ,but now is even:0,so wait even:0 i am even-thread ,but now old:1,so wait old:1 i am old-thread ,but now is even:2,so wait even:2 i am even-thread ,but now old:3,so wait old:3 i am old-thread ,but now is even:4,so wait even:4 i am even-thread ,but now old:5,so wait old:5 i am old-thread ,but now is even:6,so wait even:6 i am even-thread ,but now old:7,so wait old:7 i am old-thread ,but now is even:8,so wait even:8
上述方法使用的是 synchronize的 wait notify机制，同样可以使用显示锁来实现，两个打印的线程还是同一个线程，只是使用的是显示锁来控制等待事件
private static class MyNumber{
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
private int val;
public MyNumber(int val) {
this.val = val;
}
public int getVal() {
return val;
}
public void increase(){
lock.lock();
try {
val++;
condition.signalAll(); //通知线程
}finally {
lock.unlock();
}
}
public void waitToOld(){
lock.lock();
try{
while ((val % 2)==0){
try {
System.out.println("i am should print old ,but now is even:"+val+",so wait");
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}finally {
lock.unlock();
}
}
public void waitToEven(){
lock.lock(); //显示的锁定
try{
while ((val % 2)!=0){
try {
System.out.println("i am should print even ,but now old:"+val+",so wait");
condition.await();//执行等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}finally {
lock.unlock(); //显示的释放
}
}
}
同样可以得到上述的效果
显示锁的功能
显示锁在java中通过接口Lock提供如下功能
lock: 线程无法获取锁会进入休眠状态，直到获取成功
lockInterruptibly: 如果获取成功，立即返回，否则一直休眠到线程被中断或者是获取成功
tryLock：不会造成线程休眠，方法执行会立即返回，获取到了锁，返回true,否则返回false
tryLock(long time, TimeUnit unit) throws InterruptedException : 在等待时间内没有发生过中断，并且没有获取锁，就一直等待，当获取到了，或者是线程中断了，或者是超时时间到了这三者发生一个就返回，并记录是否有获取到锁
unlock：释放锁
newCondition：每次调用创建一个锁的等待条件，也就是说一个锁可以拥有多个条件
Condition的功能
接口Condition把Object的监视器方法wait和notify分离出来，使得一个对象可以有多个等待的条件来执行等待，配合Lock的newCondition来实现。
await:使当前线程休眠，不可调度。这四种情况下会恢复 1：其它线程调用了signal，当前线程恰好被选中了恢复执行;2: 其它线程调用了signalAll;3:其它线程中断了当前线程 4：spurious wakeup (假醒)。无论什么情况，在await方法返回之前，当前线程必须重新获取锁
awaitUninterruptibly:使当前线程休眠，不可调度。这三种情况下会恢复 1：其它线程调用了signal，当前线程恰好被选中了恢复执行;2: 其它线程调用了signalAll;3：spurious wakeup (假醒)。
awaitNanos:使当前线程休眠，不可调度。这四种情况下会恢复 1：其它线程调用了signal，当前线程恰好被选中了恢复执行;2: 其它线程调用了signalAll;3:其它线程中断了当前线程 4：spurious wakeup (假醒)。5:超时了
await(long time, TimeUnit unit) ：与awaitNanos类似，只是换了个时间单位
awaitUntil(Date deadline):与awaitNanos相似，只是指定日期之后返回，而不是指定的一段时间
signal:唤醒一个等待的线程
signalAll:唤醒所有等待的线程
ReentrantLock
从源码中可以看到，ReentrantLock的所有实现全都依赖于内部类Sync和ConditionObject。
Sync本身是个抽象类，负责手动lock和unlock,ConditionObject则实现在父类AbstractOwnableSynchronizer中，负责await与signal
Sync的继承结构如下
Sync的两个实现类，公平锁和非公平锁
公平的锁会把权限给等待时间最长的线程来执行,非公平则获取执行权限的线程与线程本身的等待时间无关
默认初始化ReentrantLock使用的是非公平锁，当然可以通过指定参数来使用公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
当执行获取锁时，实际就是去执行 Sync 的lock操作：
public void lock() {
sync.lock();
}
对应在不同的锁机制中有不同的实现
公平锁实现
final void lock() {
acquire(1);
}
非公平锁实现
final void lock() {
if (compareAndSetState(0, 1)) //先看当前锁是不是已经被占有了，如果没有，就直接将当前线程设置为占有的线程
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1); //锁已经被占有的情况下，尝试获取
}
二者都调用父类AbstractQueuedSynchronizer的方法
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) //一旦抢失败，就会进入队列，进入队列后则是依据FIFO的原则来执行唤醒
selfInterrupt();
}
当执行unlock时，对应方法在父类AbstractQueuedSynchronizer中
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
公平锁和非公平锁则分别对获取锁的方式tryAcquire 做了实现，而tryRelease的实现机制则都是一样的
公平锁实现tryAcquire
源码如下
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState(); //获取当前的同步状态
if (c == 0) {
//等于0 表示没有被其它线程获取过锁
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
//hasQueuedPredecessors 判断在当前线程的前面是不是还有其它的线程，如果有，也就是锁sync上有一个等待的线程，那么它不能获取锁，这意味着，只有等待时间最长的线程能够获取锁，这就是是公平性的体现
//compareAndSetState 看当前在内存中存储的值是不是真的是0，如果是0就设置成accquires的取值。对于JAVA，这种需要直接操作内存的操作是通过unsafe来完成，具体的实现机制则依赖于操作系统。
//存储获取当前锁的线程
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
//判断是不是当前线程获取的锁
int nextc = c + acquires;
if (nextc < 0)//一个线程能够获取同一个锁的次数是有限制的，就是int的最大值
throw new Error("Maximum lock count exceeded");
setState(nextc); //在当前的基础上再增加一次锁被持有的次数
return true;
}
//锁被其它线程持有，获取失败
return false;
}
非公平锁实现tryAcquire
获取的关键实现为nonfairTryAcquire,源码如下
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
//锁没有被持有
//可以看到这里会无视sync queue中是否有其它线程，只要执行到了当前线程，就会去获取锁
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current); //在判断一次是不是锁没有被占有，没有就去标记当前线程拥有这个锁了
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);//如果当前线程已经占有过，增加占有的次数
return true;
}
return false;
}
释放锁的机制
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread()) //只能是线程拥有这释放
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
//当占有次数为0的时候，就认为所有的锁都释放完毕了
free = true;
setExclusiveOwnerThread(null);
}
setState(c); //更新锁的状态
return free;
}
从源码的实现可以看到
ReentrantLock获取锁时，在锁已经被占有的情况下，如果占有锁的线程是当前线程，那么允许重入，即再次占有，如果由其它线程占有，则获取失败，由此可见，ReetrantLock本身对锁的持有是可重入的,同时是线程独占的。
公平与非公平就体现在，当执行的线程去获取锁的时候，公平的会去看是否有等待时间比它更长的，而非公平的就优先直接去占有锁
ReentrantLock的tryLock()与tryLock(long timeout, TimeUnit unit):
public boolean tryLock() {
//本质上就是执行一次非公平的抢锁
return sync.nonfairTryAcquire(1);
}
有时限的tryLock核心代码是 sync.tryAcquireNanos(1, unit.toNanos(timeout));，由于有超时时间，它会直接放到等待队列中，他与后面要讲的AQS的lock原理中acquireQueued的区别在于park的时间是有限的，详见源码 AbstractQueuedSynchronizer.doAcquireNanos
为什么需要显示锁
内置锁功能上有一定的局限性，它无法响应中断，不能设置等待的时间
————————————————
版权声明：本文为CSDN博主「爬蜥」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_39687783/article/details/84495381
标签：even,Java,val,lock,ReentrantLock,old,线程,原理,public 来源： https://www.cnblogs.com/wangbin2188/p/16550473.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。