深入理解Object提供的阻塞和唤醒API
深入理解Object提供的阻塞和唤醒API
前提
前段时间花了大量时间去研读JUC中同步器AbstractQueuedSynchronizer的源码实现，再结合很久之前看过的一篇关于Object提供的等待和唤醒机制的JVM实现，发现两者有不少的关联，于是决定重新研读一下Object中提供的阻塞和唤醒方法。本文阅读JDK类库源码使用的JDK版本是JDK11，因为本文内容可能不适合于其他版本。
Object提供的阻塞和唤醒API
java.lang.Object作为所有非基本类型的基类，也就是说所有java.lang.Object的子类都具备阻塞和唤醒的功能。下面详细分析Object提供的阻塞和唤醒API。
阻塞等待-wait
等待-wait()方法提供了阻塞的功能，分超时和永久阻塞的版本，实际上，底层只提供了一个JNI方法：
// 这个是底层提供的JNI方法，带超时的阻塞等待，响应中断，其他两个只是变体
public final native void wait(long timeoutMillis) throws InterruptedException;
// 变体方法1，永久阻塞，响应中断
public final void wait() throws InterruptedException {
wait(0L);
}
// 变体方法2，带超时的阻塞，超时时间分两段：毫秒和纳秒，实际上纳秒大于0直接毫秒加1(这么暴力...)，响应中断
public final void wait(long timeoutMillis, int nanos) throws InterruptedException {
if (timeoutMillis < 0) {
throw new IllegalArgumentException("timeoutMillis value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException("nanosecond timeout value out of range");
}
if (nanos > 0) {
timeoutMillis++;
}
wait(timeoutMillis);
}
也就是只有一个wait(long timeoutMillis)方法是JNI接口，其他两个方法相当于：
wait()等价于wait(0L)。wait(long timeoutMillis, int nanos)在参数合法的情况下等价于wait(timeoutMillis + 1L)。
由于wait(long timeoutMillis, int nanos)是参数最完整的方法，它的API注释特别长，这里直接翻译和摘取它注释中的核心要素：
- 当前线程阻塞等待直到被唤醒，唤醒的情况一般有三种：notify(All)被调用、线程被中断或者在指定了超时阻塞的情况下超过了指定的阻塞时间。
- 当前线程必须获取此对象的监视器锁(monitor lock)，也就是调用阻塞等待方法之前一个线程必须成为此对象的监视器锁的拥有者。
- 调用了
wait()方法之后，当前线程会把自身放到当前对象的等待集合(wait-set)，然后释放所有在此对象上的同步声明(then to relinquish any nd all synchronization claims on this object)，谨记只有当前对象上的同步声明会被释放，当前线程在其他对象上的同步锁只有在调用其wait()方法之后才会释放。 - Warning：线程被唤醒之后(
notify()或者中断)就会从等待集合(wait-set)中移除并且重新允许被线程调度器调度。通常情况下，这个被唤醒的线程会与其他线程竞争对象上的同步权(锁)，一旦线程重新控制了对象(regained control of the object)，它对对象的所有同步声明都恢复到以前的状态，即恢复到调用wait()方法时(笔者认为，其实准确来说，是调用wait()方法前)的状态。 - 如果任意线程在它调用了
wait()之前，或者调用过wait()方法之后处于阻塞等待状态，一旦线程调用了Thread#interrupt()，线程就会中断并且抛出InterruptedException异常，线程的中断状态会被清除。InterruptedException异常会延迟到在第4点提到"它对对象的所有同步声明都恢复到以前的状态"的时候抛出。
值得注意的还有：
一个线程必须成为此对象的监视器锁的拥有者才能正常调用wait()系列方法，也就是wait()系列方法必须在同步代码块(synchronized代码块)中调用，否则会抛出IllegalMonitorStateException异常，这一点是初学者或者不了解wait()的机制的开发者经常会犯的问题。
上面的五点描述可以写个简单的同步代码块伪代码时序总结一下：
final Object lock = new Object();
synchronized(lock){
1、线程进入同步代码块，意味着获取对象监视器锁成功
while(!condition){
lock.wait(); 2.线程调用wait()进行阻塞等待
break;
}
3.线程从wait()的阻塞等待中被唤醒，恢复到第1步之后的同步状态
4.继续执行后面的代码，直到离开同步代码块
}
唤醒-notify
notify()方法的方法签名如下：
@HotSpotIntrinsicCandidate
public final native void notify();
下面按照惯例翻译一下其API注释：
- 唤醒一个阻塞等待在此对象监视器上的线程，(如果存在多个阻塞线程)至于选择哪一个线程进行唤醒是任意的，取决于具体的现实，一个线程通过调用
wait()方法才能阻塞在对象监视器上。 - 被唤醒的线程并不会马上继续执行，直到当前线程(也就是当前调用了
notify()方法的线程)释放对象上的锁。被唤醒的线程会与其他线程竞争在对象上进行同步(换言之只有获得对象的同步控制权才能继续执行)，在成为下一个锁定此对象的线程时，被唤醒的线程没有可靠的特权或劣势。 - 此方法只有在一个线程获取了此对象监视器的所有权(the owner)的时候才能调用，具体就是：同步方法中、同步代码块中或者静态同步方法中。否则，会抛出
IllegalMonitorStateException异常。
唤醒所有-notifyAll
notifyAll()方法的方法签名如下：
@HotSpotIntrinsicCandidate
public final native void notifyAll();
1.唤醒所有阻塞等待在此对象监视器上的线程，一个线程通过调用wait()方法才能阻塞在对象监视器上。
其他注释的描述和notify()方法类似。
小结
我们经常看到的资料中提到synchronized关键字的用法：
- 普通同步方法，同步或者说锁定的是当前实例对象。
- 静态同步方法，同步或者说锁定的是当前实例对象的
Class对象。 - 同步代码块，同步或者说锁定的是括号里面的实例对象。
对于同步代码块而言，synchronized关键字抽象到字节码层面就是同步代码块中的字节码执行在monitorenter和monitorexit指令之间：
synchronized(xxxx){
...coding block
}
↓↓↓↓↓↓↓↓↓↓
monitorenter;
...coding block - bytecode
monitorexit;
JVM需要保证每一个monitorenter都有一个monitorexit与之相对应。任何对象都有一个monitor(实际上是ObjectMonitor)与之相关联，当且一个monitor被持有之后，它将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象所对应的monitor所有权，即尝试获取对象的锁。
对于同步(静态)方法而言，synchronized方法则会被翻译成普通的方法调用和返回指令，如：invokevirtual等等，在JVM字节码层面并没有任何特别的指令来实现被synchronized修饰的方法，而是在Class文件的方法表中将该方法的access_flags字段中的synchronized标志位置1，表示该方法是同步方法并使用调用该方法的对象或该方法所属的Class在JVM的内部对象表示Klass做为锁对象。
其实从开发者角度简单理解，这两种方式只是在获取锁的时机有所不同。
下面重复阐述几个第一眼看起来不合理却是事实的问题(其实前文已经提及过)：
- 在线程进入
synchronized方法或者代码块，相当于获取监视器锁成功，如果此时成功调用wait()系列方法，那么它会立即释放监视器锁，并且添加到等待集合(Wait Set)中进行阻塞等待。 - 由于已经有线程释放了监视器锁，那么在另一个线程进入
synchronized方法或者代码块之后，它可以调用notify(All)方法唤醒等待集合中正在阻塞的线程，但是这个唤醒操作并不是调用notify(All)方法后立即生效，而是在该线程退出synchronized方法或者代码块之后才生效。 - 从
wait()方法阻塞过程中被唤醒的线程会竞争监视器目标对象的控制权，一旦重新控制了对象，那么线程的同步状态就会恢复到步入synchronized方法或者代码块时候的状态(也就是成功获取到对象监视器锁时候的状态)，这个时候线程才能够继续执行。
为了验证这三点，可以写个简单的Demo：
public class Lock {
@Getter
private final Object lock = new Object();
}
public class WaitMain {
private static final DateTimeFormatter F = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
public static void main(String[] args) throws Exception {
final Lock lock = new Lock();
new Thread(new WaitRunnable(lock), "WaitThread-1").start();
new Thread(new WaitRunnable(lock), "WaitThread-2").start();
Thread.sleep(50);
new Thread(new NotifyRunnable(lock), "NotifyThread").start();
Thread.sleep(Integer.MAX_VALUE);
}
@RequiredArgsConstructor
private static class WaitRunnable implements Runnable {
private final Lock lock;
@Override
public void run() {
synchronized (lock) {
System.out.println(String.format("[%s]-线程[%s]获取锁成功,准备执行wait方法", F.format(LocalDateTime.now()),
Thread.currentThread().getName()));
while (true) {
try {
lock.wait();
} catch (InterruptedException e) {
//ignore
}
System.out.println(String.format("[%s]-线程[%s]从wait中唤醒,准备exit", F.format(LocalDateTime.now()),
Thread.currentThread().getName()));
try {
Thread.sleep(500);
} catch (InterruptedException e) {
//ignore
}
break;
}
}
}
}
@RequiredArgsConstructor
private static class NotifyRunnable implements Runnable {
private final Lock lock;
@Override
public void run() {
synchronized (lock) {
System.out.println(String.format("[%s]-线程[%s]获取锁成功,准备执行notifyAll方法", F.format(LocalDateTime.now()),
Thread.currentThread().getName()));
lock.notifyAll();
System.out.println(String.format("[%s]-线程[%s]先休眠3000ms", F.format(LocalDateTime.now()),
Thread.currentThread().getName()));
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
//ignore
}
System.out.println(String.format("[%s]-线程[%s]准备exit", F.format(LocalDateTime.now()),
Thread.currentThread().getName()));
}
}
}
}
某个时刻的执行结果如下：
[2019-04-27 23:28:17.617]-线程[WaitThread-1]获取锁成功,准备执行wait方法
[2019-04-27 23:28:17.631]-线程[WaitThread-2]获取锁成功,准备执行wait方法
[2019-04-27 23:28:17.657]-线程[NotifyThread]获取锁成功,准备执行notifyAll方法 <-------- 这一步执行完说明WaitThread已经释放了锁
[2019-04-27 23:28:17.657]-线程[NotifyThread]先休眠3000ms
[2019-04-27 23:28:20.658]-线程[NotifyThread]准备exit <------- 这一步后NotifyThread离开同步代码块
[2019-04-27 23:28:20.658]-线程[WaitThread-1]从wait中唤醒,准备exit <------- 这一步WaitThread-1解除阻塞
[2019-04-27 23:28:21.160]-线程[WaitThread-2]从wait中唤醒,准备exit <------- 这一步WaitThread-2解除阻塞，注意发生时间在WaitThread-1解除阻塞500ms之后，符合我们前面提到的第3点
如果结合wait()和notify()可以简单总结出一个同步代码块的伪代码如下：
final Object lock = new Object();
// 等待
synchronized(lock){
1、线程进入同步代码块，意味着获取对象监视器锁成功
while(!condition){
lock.wait(); 2.线程调用wait()进行阻塞等待
break;
}
3.线程从wait()的阻塞等待中被唤醒，尝试恢复第1步之后的同步状态，并不会马上生效，直到notify被调用并且调用notify方法的线程已经释放锁，同时当前线程需要竞争成功
4.继续执行后面的代码，直到离开同步代码块
}
// 唤醒
synchronized(lock){
1、线程进入同步代码块，意味着获取对象监视器锁成功
lock.notify(); 2.唤醒其中一个在对象监视器上等待的线程
3.准备推出同步代码块释放锁，只有释放锁之后第2步才会生效
}
图解Object提供的阻塞和唤醒机制
结合前面分析过的知识点以及参考资料中的文章，重新画一个图理解一下对象监视器以及相应阻塞和唤醒API的工作示意过程：
- Entry Set(实际上是
ObjectMonitor中的_EntryList属性)：存放等待锁并且处于阻塞状态的线程。 - Wait Set(实际上是
ObjectMonitor中的_WaitSet属性)：存放处于等待阻塞状态的线程。 - The Owner(实际上是
ObjectMonitor中的_owner属性)：指向获得对象监视器的线程，在同一个时刻只能有一个线程被The Owner持有，通俗来看，它就是监视器的控制权。
使用例子
通过Object提供的阻塞和唤醒机制举几个简单的使用例子。
维修厕所的例子
假设有以下场景：厕所的只有一个卡位，厕所维修工修厕所的时候，任何人不能上厕所。当厕所维修工修完厕所的时候，上厕所的人需要"得到厕所的控制权"才能上厕所。
// 厕所类
public class Toilet {
// 厕所的锁
private final Object lock = new Object();
private boolean available;
public Object getLock() {
return lock;
}
public void setAvailable(boolean available) {
this.available = available;
}
public boolean getAvailable() {
return available;
}
}
// 厕所维修工
@RequiredArgsConstructor
public class ToiletRepairer implements Runnable {
private static final DateTimeFormatter F = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
private final Toilet toilet;
@Override
public void run() {
synchronized (toilet.getLock()) {
System.out.println(String.format("[%s]-厕所维修员得到了厕所的锁,维修厕所要用5000ms...", LocalDateTime.now().format(F)));
try {
Thread.sleep(5000);
} catch (Exception e) {
// ignore
}
toilet.setAvailable(true);
toilet.getLock().notifyAll();
System.out.println(String.format("[%s]-厕所维修员维修完毕...", LocalDateTime.now().format(F)));
}
}
}
//上厕所的任务
@RequiredArgsConstructor
public class ToiletTask implements Runnable {
private static final DateTimeFormatter F = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
private final Toilet toilet;
private final String name;
private final Random random;
@Override
public void run() {
synchronized (toilet.getLock()) {
System.out.println(String.format("[%s]-%s得到了厕所的锁...", LocalDateTime.now().format(F), name));
while (!toilet.getAvailable()) {
try {
toilet.getLock().wait();
} catch (InterruptedException e) {
//ignore
}
int time = random.nextInt(3) + 1;
try {
// 模拟上厕所用时
TimeUnit.SECONDS.sleep(time);
} catch (InterruptedException e) {
//ignore
}
System.out.println(String.format("[%s]-%s上厕所用了%s秒...", LocalDateTime.now().format(F), name, time));
}
}
}
}
// 场景入口
public class Main {
public static void main(String[] args) throws Exception {
Toilet toilet = new Toilet();
Random random = new Random();
Thread toiletRepairer = new Thread(new ToiletRepairer(toilet), "ToiletRepairer");
Thread thread1 = new Thread(new ToiletTask(toilet, "张三", random), "thread-1");
Thread thread2 = new Thread(new ToiletTask(toilet, "李四", random), "thread-2");
Thread thread3 = new Thread(new ToiletTask(toilet, "王五", random), "thread-3");
thread1.start();
thread2.start();
thread3.start();
Thread.sleep(50);
toiletRepairer.start();
Thread.sleep(Integer.MAX_VALUE);
}
}
某次执行的结果如下：
[2019-04-29 01:07:25.914]-张三得到了厕所的锁...
[2019-04-29 01:07:25.931]-李四得到了厕所的锁...
[2019-04-29 01:07:25.931]-王五得到了厕所的锁...
[2019-04-29 01:07:25.951]-厕所维修员得到了厕所的锁,维修厕所要用5000ms...
[2019-04-29 01:07:30.951]-厕所维修员维修完毕...
[2019-04-29 01:07:32.952]-张三上厕所用了2秒...
[2019-04-29 01:07:35.952]-王五上厕所用了3秒...
[2019-04-29 01:07:37.953]-李四上厕所用了2秒...
阻塞队列实现
实现一个简单固定容量的阻塞队列，接口如下：
public interface BlockingQueue<T> {
void put(T value) throws InterruptedException;
T take() throws InterruptedException;
}
其中put(T value)会阻塞直到队列中有可用的容量，而take()方法会阻塞直到有元素投放到队列中。实现如下：
public class DefaultBlockingQueue<T> implements BlockingQueue<T> {
private Object[] elements;
private final Object notEmpty = new Object();
private final Object notFull = new Object();
private int count;
private int takeIndex;
private int putIndex;
public DefaultBlockingQueue(int capacity) {
this.elements = new Object[capacity];
}
@Override
public void put(T value) throws InterruptedException {
synchronized (notFull) {
while (count == elements.length) {
notFull.wait();
}
}
final Object[] items = this.elements;
items[putIndex] = value;
if (++putIndex == items.length) {
putIndex = 0;
}
count++;
synchronized (notEmpty) {
notEmpty.notify();
}
}
@SuppressWarnings("unchecked")
@Override
public T take() throws InterruptedException {
synchronized (notEmpty) {
while (count == 0) {
notEmpty.wait();
}
}
final Object[] items = this.elements;
T value = (T) items[takeIndex];
items[takeIndex] = null;
if (++takeIndex == items.length) {
takeIndex = 0;
}
count--;
synchronized (notFull) {
notFull.notify();
}
return value;
}
}
场景入口类：
public class Main {
public static void main(String[] args) throws Exception {
BlockingQueue<String> queue = new DefaultBlockingQueue<>(5);
Runnable r = () -> {
while (true) {
try {
String take = queue.take();
System.out.println(String.format("线程%s消费消息-%s", Thread.currentThread().getName(), take));
} catch (Exception e) {
e.printStackTrace();
}
}
};
new Thread(r, "thread-1").start();
new Thread(r, "thread-2").start();
IntStream.range(0, 10).forEach(i -> {
try {
queue.put(String.valueOf(i));
} catch (InterruptedException e) {
//ignore
}
});
Thread.sleep(Integer.MAX_VALUE);
}
}
某次执行结果如下：
线程thread-1消费消息-0
线程thread-2消费消息-1
线程thread-1消费消息-2
线程thread-2消费消息-3
线程thread-1消费消息-4
线程thread-2消费消息-5
线程thread-1消费消息-6
线程thread-2消费消息-7
线程thread-1消费消息-8
线程thread-2消费消息-9
上面这个例子就是简单的单生产者-多消费者的模型。
线程池实现
这里实现一个极度简陋的固定容量的线程池，功能是：初始化固定数量的活跃线程，阻塞直到有可用的线程用于提交任务。它只有一个接口方法，接口定义如下：
public interface ThreadPool {
void execute(Runnable runnable);
}
具体实现如下：
public class DefaultThreadPool implements ThreadPool {
private final int capacity;
private List<Worker> initWorkers;
private Deque<Worker> availableWorkers;
private Deque<Worker> busyWorkers;
private final Object nextLock = new Object();
public DefaultThreadPool(int capacity) {
this.capacity = capacity;
init(capacity);
}
private void init(int capacity) {
initWorkers = new ArrayList<>(capacity);
availableWorkers = new LinkedList<>();
busyWorkers = new LinkedList<>();
for (int i = 0; i < capacity; i++) {
Worker worker = new Worker();
worker.setName("Worker-" + (i + 1));
worker.setDaemon(true);
initWorkers.add(worker);
}
for (Worker w : initWorkers) {
w.start();
availableWorkers.add(w);
}
}
@Override
public void execute(Runnable runnable) {
if (null == runnable) {
return;
}
synchronized (nextLock) {
while (availableWorkers.size() < 1) {
try {
nextLock.wait(500);
} catch (InterruptedException e) {
//ignore
}
}
Worker worker = availableWorkers.removeFirst();
busyWorkers.add(worker);
worker.run(runnable);
nextLock.notifyAll();
}
}
private void makeAvailable(Worker worker) {
synchronized (nextLock) {
availableWorkers.add(worker);
busyWorkers.remove(worker);
nextLock.notifyAll();
}
}
private class Worker extends Thread {
private final Object lock = new Object();
private Runnable runnable;
private AtomicBoolean run = new AtomicBoolean(true);
private void run(Runnable runnable) {
synchronized (lock) {
if (null != this.runnable) {
throw new IllegalStateException("Already running a Runnable!");
}
this.runnable = runnable;
lock.notifyAll();
}
}
@Override
public void run() {
boolean ran = false;
while (run.get()) {
try {
synchronized (lock) {
while (runnable == null && run.get()) {
lock.wait(500);
}
if (runnable != null) {
ran = true;
runnable.run();
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
synchronized (lock) {
runnable = null;
}
if (ran) {
ran = false;
makeAvailable(this);
}
}
}
}
}
}
场景类入口：
public class Main {
private static final DateTimeFormatter F = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
public static void main(String[] args) throws Exception{
ThreadPool threadPool = new DefaultThreadPool(2);
threadPool.execute(() -> {
try {
System.out.println(String.format("[%s]-任务一开始执行持续3秒...", LocalDateTime.now().format(F)));
Thread.sleep(3000);
System.out.println(String.format("[%s]-任务一执行结束...", LocalDateTime.now().format(F)));
}catch (Exception e){
//ignore
}
});
threadPool.execute(() -> {
try {
System.out.println(String.format("[%s]-任务二开始执行持续4秒...", LocalDateTime.now().format(F)));
Thread.sleep(4000);
System.out.println(String.format("[%s]-任务二执行结束...", LocalDateTime.now().format(F)));
}catch (Exception e){
//ignore
}
});
threadPool.execute(() -> {
try {
System.out.println(String.format("[%s]-任务三开始执行持续5秒...", LocalDateTime.now().format(F)));
Thread.sleep(5000);
System.out.println(String.format("[%s]-任务三执行结束...", LocalDateTime.now().format(F)));
}catch (Exception e){
//ignore
}
});
Thread.sleep(Integer.MAX_VALUE);
}
}
某次执行结果如下：
[2019-04-29 02:07:25.465]-任务二开始执行持续4秒...
[2019-04-29 02:07:25.465]-任务一开始执行持续3秒...
[2019-04-29 02:07:28.486]-任务一执行结束...
[2019-04-29 02:07:28.486]-任务三开始执行持续5秒...
[2019-04-29 02:07:29.486]-任务二执行结束...
[2019-04-29 02:07:33.487]-任务三执行结束...
小结
鉴于笔者C语言学得不好，这里就无法深入分析JVM源码的实现，只能结合一些现有的资料和自己的理解重新梳理一下Object提供的阻塞和唤醒机制这些知识点。结合之前看过JUC同步器的源码，一时醒悟过来，JUC同步器只是在数据结构和算法层面使用Java语言对原来JVM中C语言的阻塞和唤醒机制即Object提供的那几个JNI方法进行了一次实现而已。
最后，Object提供的阻塞等待唤醒机制是JVM实现的(如果特别熟悉C语言可以通过JVM源码研究其实现，对于大部分开发者来说是黑箱)，除非是特别熟练或者是JDK版本太低尚未引入JUC包，一般情况下不应该优先选择Object，而应该考虑专门为并发设计的JUC包中的类库。
参考资料：
原文链接
Github Page：http://www.throwable.club/2019/04/30/java-object-wait-notify/
Coding Page：http://throwable.coding.me/2019/04/30/java-object-wait-notify/
(本文完 c-7-d e-a-20190430)
深入理解Object提供的阻塞和唤醒API的更多相关文章
- 多线程之Java线程阻塞与唤醒
线程的阻塞和唤醒在多线程并发过程中是一个关键点,当线程数量达到很大的数量级时,并发可能带来很多隐蔽的问题.如何正确暂停一个线程,暂停后又如何在一个要求的时间点恢复,这些都需要仔细考虑的细节.在Java ...
- 阻塞和唤醒线程——LockSupport功能简介及原理浅析
目录 1.LockSupport功能简介 1.1 使用wait,notify阻塞唤醒线程 1.2 使用LockSupport阻塞唤醒线程 2. LockSupport的其他特色 2.1 可以先唤醒线程 ...
- Java并发框架——AQS之阻塞与唤醒
根据前面的线程阻塞与唤醒小节知道,目前在Java语言层面能实现阻塞唤醒的方式一共有三种:suspend与resume组合.wait与notify组合.park与unpark组合.其中suspend与r ...
- 从JDK源码角度看线程的阻塞和唤醒
目前在Java语言层面能实现阻塞唤醒的方式一共有三种:suspend与resume组合.wait与notify组合.park与unpark组合.其中suspend与resume因为存在无法解决的竟态问 ...
- J.U.C之AQS：阻塞和唤醒线程
此篇博客所有源码均来自JDK 1.8 在线程获取同步状态时如果获取失败,则加入CLH同步队列,通过通过自旋的方式不断获取同步状态,但是在自旋的过程中则需要判断当前线程是否需要阻塞,其主要方法在acqu ...
- 理解Object.defineProperty()
理解Object.defineProperty() Object.defineProperty() 方法直接在一个对象上定义一个新属性,或者修改一个已经存在的属性, 并返回这个对象. 基本语法:Obj ...
- 深入理解 Object.defineProperty 及实现数据双向绑定
Object.defineProperty() 和 Proxy 对象,都可以用来对数据的劫持操作.何为数据劫持呢?就是在我们访问或者修改某个对象的某个属性的时候,通过一段代码进行拦截行为,然后进行额外 ...
- 【并发】3、LockSupport阻塞与唤醒，相较与wait和notify
我们可以使用wait和notify分别对象线程进行阻塞或者唤醒,但是我们也可以使用LockSupport实现一样的功能,并且在实际使用的时候,个人感觉LockSupport会更加顺手 范例1,wait ...
- 理解 Object.defineProperty
理解 Object.defineProperty 本文写于 2020 年 10 月 13 日 Object.defineProperty 用于在一个对象上定义新的属性或修改现有属性并返回该对象. 什么 ...
随机推荐
- 【原】不定义Order属性，通过切面类的定义顺序来决定通知执行的先后顺序
[结论] 在多个切面类的“切入点相同”并且每个切面都“没有定义order属性”的情况下,则切面类(中的通知)的执行顺序与该切面类在<aop:config>元素中“声明的顺序”相关,即先声明 ...
- 简单的文件上传html+ashx
前台页面:<form action="upload.ashx" method="post" enctype="multipart/form-da ...
- 算法学习 - 平衡二叉查找树实现(AVL树)
平衡二叉查找树 平衡二叉查找树是非常早出现的平衡树,由于全部子树的高度差不超过1,所以操作平均为O(logN). 平衡二叉查找树和BS树非常像,插入和删除操作也基本一样.可是每一个节点多了一个高度的信 ...
- [原] corePlot 类库与iOS自带类库使用方法对比（很多开源代码都有这个特点）
——人类最倚重的是自己的“以往经验”.—— 我们直接看一下在corePlot 类库和iOS自带类中为一个控件设置文本显示格式的实现. * corePlot 类库中,为一个对象设置标题显示格式 , ...
- ios 重用UI部分代码的好方法（再也不用为局部变量的命名而烦恼啦！）
重用控件类代码的一个非常好的解决方案:所有一样的控件其名字均用同样的一个名字.只是在最后赋值的时候,将创建好的控件赋给我们需要用到的那个控件. - (id)initWithFrame:(CGRect) ...
- 几款开源的ETL工具及ELT初探
ETL,是英文 Extract-Transform-Load 的缩写,用来描述将数据从来源端经过抽取(extract).转换(transform).加载(load)至目的端的过程.ETL 是构建数据仓 ...
- Google浏览器Chrome安装失败,错误代码0xa0430721解决办法
谷歌浏览器安装失败错误代码0xa0430721 的解决办法 这个是因为我们删除的时候没有删除干净.然后又重装了谷歌浏览器.所以就出现这个问题了. 1.删除旧的配置文件,比如C:\Documents a ...
- 仿LOL项目开发第七天
仿LOL项目开发第七天 by 草帽 不知不觉已经写到了第七篇这种类型的博客,但是回过头看看之前写的,发现都只能我自己能看懂. 我相信在看的童鞋云里雾里的,因为我基本上没怎么详细讲一个脚本怎么用?但是你 ...
- Android之判断时间是否为今天
字符串: sdate = 2013-07-16 13:35:02 /** * 判断给定字符串时间是否为今日 * @param sdate * @return boolean */ publ ...
- Ubuntu 16.04 重置密码
忘记了你的Ubuntu用户密码,登录不了系统:不要紧,在Ubuntu上重置密码是很简单的,即使你忘记了用户名. #1 进入Recovery Mode Recovery Mode即恢复模式:在Grub启 ...