在 Java 中，使用 Thread 类可以在操作系统层面创建线程，并绑定到对应的 Thread 类实例中。利用线程异步地执行任务，是并发编程的基础。本文通过阅读 Thread 源码，了解线程状态的定义，线程调度的相关方法，以及对线程中断的处理等。
本文基于 jdk1.8.0_91
线程类 Thread 实现了 Runnable 接口，并且具有一个 Runnable 属性，表示需要线程执行的任务。
Thread#run 方法内部调用了属性 Runnable 的 run 方法；若 Runnable 属性为空则什么也不做。
/**
* A <i>thread</i> is a thread of execution in a program. The Java
* Virtual Machine allows an application to have multiple threads of
* execution running concurrently.
*
* @author unascribed
* @see Runnable
* @see Runtime#exit(int)
* @see #run()
* @see #stop()
* @since JDK1.0
*/
public class Thread implements Runnable {
/* What will be run. */
private Runnable target;
/**
* If this thread was constructed using a separate
* <code>Runnable</code> run object, then that
* <code>Runnable</code> object's <code>run</code> method is called;
* otherwise, this method does nothing and returns.
* <p>
* Subclasses of <code>Thread</code> should override this method.
*
* @see #start()
* @see #stop()
* @see #Thread(ThreadGroup, Runnable, String)
*/
@Override
public void run() {
if (target != null) {
target.run();
}
}
}如果直接执行 Thread#run 只是一个普通的调用，并不会启动新的线程来执行任务。
正确是用法是执行 Thread#start 来启动新的线程，由该线程来调用 Thread#run 执行任务。
“创建线程”是一个模糊的概念，某些场景下指的是在内存中创建 Thread 类的实例，在另一些场景下指的是在操作系统层面创建原生线程。为了区分这两种截然不同的情况，本文将创建 Thread 类的实例称为 “创建线程”，将创建操作系统原生线程称为 “启动线程”。
public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}
public Thread(String name) {
init(null, null, name, 0);
}
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
public Thread(Runnable target, String name) {
init(null, target, name, 0);
}
public Thread(ThreadGroup group, Runnable target) {
init(group, target, "Thread-" + nextThreadNum(), 0);
}
public Thread(ThreadGroup group, String name) {
init(group, null, name, 0);
}
public Thread(ThreadGroup group, Runnable target, String name) {
init(group, target, name, 0);
}
public Thread(ThreadGroup group, Runnable target, String name, long stackSize) {
init(group, target, name, stackSize);
}最终都是调用 Thread#init 方法：
/**
* Initializes a Thread with the current AccessControlContext.
* @see #init(ThreadGroup,Runnable,String,long,AccessControlContext)
*/
private void init(ThreadGroup g, Runnable target, String name,
long stackSize) {
init(g, target, name, stackSize, null);
}
/**
* Initializes a Thread.
*
* @param g the Thread group
* @param target the object whose run() method gets called
* @param name the name of the new Thread
* @param stackSize the desired stack size for the new thread, or
* zero to indicate that this parameter is to be ignored.
* @param acc the AccessControlContext to inherit, or
* AccessController.getContext() if null
*/
private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc) {
...
}入参说明：
在 JDK 官方文档中，介绍了 Thread 类实例化的两种方式：
There are two ways to create a new thread of execution.
One is to declare a class to be a subclass ofThread. This subclass should override therunmethod of classThread. An instance of the subclass can then be allocated and started.
The other way to create a thread is to declare a class that implements theRunnableinterface. That class then implements therunmethod. An instance of the class can then be allocated, passed as an argument when creatingThread, and started.
编写 Thread 的子类，重写 Thread 类的 run 方法。创建该子类的实例以启动线程执行任务。
例如，计算大于某一规定值的质数的线程可以写成：
class PrimeThread extends Thread {
long minPrime;
PrimeThread(long minPrime) {
this.minPrime = minPrime;
}
public void run() {
// compute primes larger than minPrime
...
}
}下列代码会创建并启动一个线程：
PrimeThread p = new PrimeThread(143);
p.start();编写 Runnable 接口实现类，实现 Runnable 接口的 run 方法。在创建 Thread 时将该 Runnable 类的实例作为一个参数来传递。
class PrimeRun implements Runnable {
long minPrime;
PrimeRun(long minPrime) {
this.minPrime = minPrime;
}
public void run() {
// compute primes larger than minPrime
...
}
}下列代码会创建并启动一个线程：
PrimeRun p = new PrimeRun(143);
new Thread(p).start();执行 new java.lang.Thread().start() 会在操作系统上创建并启动一个原生线程。
java.lang.Thread#start
/**
* Causes this thread to begin execution; the Java Virtual Machine
* calls the <code>run</code> method of this thread.
* <p>
* The result is that two threads are running concurrently: the
* current thread (which returns from the call to the
* <code>start</code> method) and the other thread (which executes its
* <code>run</code> method).
* <p>
* It is never legal to start a thread more than once.
* In particular, a thread may not be restarted once it has completed
* execution.
*
* @exception IllegalThreadStateException if the thread was already
* started.
* @see #run()
* @see #stop()
*/
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0(); // 由 JVM 映射到系统层面，创建线程！
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
private native void start0();根据《深入理解 Java 虚拟机》第十二章第四节，实现线程主要有三种方式：
HotSpot 虚拟机采用 1：1 的线程模型，它的每一个 Java 线程都是直接映射到一个操作系统原生线程来实现的，而且中间没有额外的间接结构，所以 HotSpot 自己是不会去干涉线程调度的（可以设置线程优先级给操作系统提供调度建议），全权交给底下的操作系统去处理，所以何时冻结或唤醒线程、该给线程分配多少处理器执行时间、该把线程安排给哪个处理器核心去执行等，都是由操作系统完成的，也都是由操作系统全权决定的。
在 java.lang.Thread 类中，定义了 threadStatus 属性和 State 枚举来描述线程的状态。
/* Java thread status for tools,
* initialized to indicate thread 'not yet started'
*/
private volatile int threadStatus = 0;
/**
* A thread state.
* <p>
* A thread can be in only one state at a given point in time.
* These states are virtual machine states which do not reflect
* any operating system thread states.
*
* @since 1.5
* @see #getState
*/
public enum State {
/**
* Thread state for a thread which has not yet started.
*/
NEW,
/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
RUNNABLE,
/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
BLOCKED,
/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul>
* <li>{@link Object#wait() Object.wait} with no timeout</li>
* <li>{@link #join() Thread.join} with no timeout</li>
* <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.join()</tt>
* is waiting for a specified thread to terminate.
*/
WAITING,
/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
* <ul>
* <li>{@link #sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link #join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
}根据定义，线程具有 6 种状态：
线程在同一时间下，只会处于一种状态。这些状态是在 JVM 层面的，不会映射到操作系统层面的线程状态。
尚未启动的线程处于该状态。
在 JVM 中运行的线程处于该状态。
该状态下的线程正在 JVM 中运行，但是可能需要等待操作系统的资源，如 CPU 调度等。
等待监视器锁（monitor lock）的线程处于这个状态。
分为两种情况：
无限期等待中的线程处于该状态。
调用以下方法之一，线程会处于该状态。
处于等待状态的线程，在等待的是其他线程执行特定的操作。
有限期等待中的线程处于该状态。
调用以下方法之一（入参均需要传入超时时间），线程会处于该状态。
已退出的线程处于该状态。
说明线程已经结束运行。
Java 线程 6 种状态看起来挺复杂的，但其实 BLOCKED，WATTING，TIMED_WAITING 都会使线程处于阻塞状态，所以我们将这三类都归类为阻塞状态。因此，Java 线程生命周期就可以简化为下图：
在 java.lang.Thread 类中，定义了 getState() 方法获取线程的状态，定义了 isAlive() 方法判断当前线程是否活跃。
/**
* Returns the state of this thread.
* This method is designed for use in monitoring of the system state,
* not for synchronization control.
*
* @return this thread's state.
* @since 1.5
*/
public State getState() {
// get current thread state
return sun.misc.VM.toThreadState(threadStatus);
}
/**
* Tests if this thread is alive. A thread is alive if it has
* been started and has not yet died.
*
* @return <code>true</code> if this thread is alive;
* <code>false</code> otherwise.
*/
public final native boolean isAlive();利用 isAlive() 方法，可以用于判断当前 Thread 类实例是否绑定了系统原生线程。
@Test
public void state() throws InterruptedException {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
System.out.println("thread.isAlive() = " + thread.isAlive()); // false
System.out.println("thread.getState() = " + thread.getState());// NEW
thread.start();
Thread.sleep(200);
System.out.println("thread.isAlive() = " + thread.isAlive()); // true
System.out.println("thread.getState() = " + thread.getState());// TIMED_WAITING
thread.join();
System.out.println("thread.isAlive() = " + thread.isAlive()); // false
System.out.println("thread.getState() = " + thread.getState());// TERMINATED
}当前线程调用 Thread#sleep、Object#wait、Thread#join 都会进入等待状态（WAITING/TIMED_WAITING）。
/**
* Causes the currently executing thread to sleep (temporarily cease
* execution) for the specified number of milliseconds, subject to
* the precision and accuracy of system timers and schedulers. The thread
* does not lose ownership of any monitors.
*
* @param millis
* the length of time to sleep in milliseconds
*
* @throws IllegalArgumentException
* if the value of {@code millis} is negative
*
* @throws InterruptedException
* if any thread has interrupted the current thread. The
* <i>interrupted status</i> of the current thread is
* cleared when this exception is thrown.
*/
public static native void sleep(long millis) throws InterruptedException;Thread#sleep 还有另外一个版本，允许同时传入毫秒值和纳秒值，但是多出来的 nanos 最多只会让线程多休眠 1 毫秒，不常用。Thread#join 和 Object#wait 中都具有类似的需要传入毫秒值和纳秒值的方法，后续不再赘述。
/**
* Causes the currently executing thread to sleep (temporarily cease
* execution) for the specified number of milliseconds plus the specified
* number of nanoseconds, subject to the precision and accuracy of system
* timers and schedulers. The thread does not lose ownership of any
* monitors.
*
* @param millis
* the length of time to sleep in milliseconds // 毫秒
*
* @param nanos
* {@code 0-999999} additional nanoseconds to sleep // 纳秒
*
* @throws IllegalArgumentException
* if the value of {@code millis} is negative, or the value of
* {@code nanos} is not in the range {@code 0-999999}
*
* @throws InterruptedException
* if any thread has interrupted the current thread. The
* <i>interrupted status</i> of the current thread is
* cleared when this exception is thrown.
*/
public static void sleep(long millis, int nanos)
throws InterruptedException {
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}
sleep(millis);
}关于 Thread#sleep(0)
/**
* Causes the current thread to wait until another thread invokes the
* {@link java.lang.Object#notify()} method or the
* {@link java.lang.Object#notifyAll()} method for this object, or
* some other thread interrupts the current thread, or a certain
* amount of real time has elapsed.
*/
public final native void wait(long timeout) throws InterruptedException;
/**
* Causes the current thread to wait until another thread invokes the
* {@link java.lang.Object#notify()} method or the
* {@link java.lang.Object#notifyAll()} method for this object.
* In other words, this method behaves exactly as if it simply
* performs the call {@code wait(0)}.
*/
public final void wait() throws InterruptedException {
wait(0);
}用法示例：
synchronized (obj) {
while (<condition does not hold>) {
obj.wait();
}
... // Perform action appropriate to condition
}关于 Object#wait(0)
/**
* Waits for this thread to die.
*/
public final void join() throws InterruptedException {
join(0);
}
/**
* Waits at most {@code millis} milliseconds for this thread to
* die. A timeout of {@code 0} means to wait forever.
*
* <p> This implementation uses a loop of {@code this.wait} calls
* conditioned on {@code this.isAlive}. As a thread terminates the
* {@code this.notifyAll} method is invoked. It is recommended that
* applications not use {@code wait}, {@code notify}, or
* {@code notifyAll} on {@code Thread} instances.
*
* @param millis
* the time to wait in milliseconds
*
* @throws IllegalArgumentException
* if the value of {@code millis} is negative
*
* @throws InterruptedException
* if any thread has interrupted the current thread. The
* <i>interrupted status</i> of the current thread is
* cleared when this exception is thrown.
*/
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}调用 Thread#join 涉及到两个线程之间的交互。
比如线程 threadA 在运行过程中，碰到 threadB.join() 这一行代码，表示 threadA 需要进入等待，直到 threadB 执行完成。
分析一下整个过程：
threadB.join()，由于 Thread#join 方法是非静态的、由 synchronized 修饰的，threadA 首先需要获取 threadB 这个对象的锁。this.isAlive() 是 threadB 对象的方法，因此是 threadA 来检查 threadB 是否存活。threadB.wait() 会释放锁，进入无限期等待状态 WAITING。threadB.notifyAll() 方法唤醒在 threadB.wait() 上等待的线程。JDK 源码注释中说明了，当线程终止时，会调用 Object#notifyAll 方法。
As a thread terminates the {@code this.notifyAll} method is invoked.
示例代码：
@Test
public void join() throws InterruptedException {
Thread threadB = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() + " 开始运行...");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " 结束运行...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "threadB");
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() + " 开始运行...");
threadB.start();
threadB.join();
System.out.println(Thread.currentThread().getName() + " 结束运行...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "threadA");
threadA.start();
threadA.join();
}执行结果：
threadA 开始运行...
threadB 开始运行...
threadB 结束运行...
threadA 结束运行...关于 Thread#join(0)
Thread#join() 内部实际上是调用 Thread#join(timeout)，超时时间为 0 毫秒，指的是没有超时时间。
线程调用 Thread#yield 并不会进入等待状态。
/**
* A hint to the scheduler that the current thread is willing to yield
* its current use of a processor. The scheduler is free to ignore this
* hint.
*
* <p> Yield is a heuristic attempt to improve relative progression
* between threads that would otherwise over-utilise a CPU. Its use
* should be combined with detailed profiling and benchmarking to
* ensure that it actually has the desired effect.
*
* <p> It is rarely appropriate to use this method. It may be useful
* for debugging or testing purposes, where it may help to reproduce
* bugs due to race conditions. It may also be useful when designing
* concurrency control constructs such as the ones in the
* {@link java.util.concurrent.locks} package.
*/
public static native void yield();中断（Interrupt）一个线程意味着在该线程完成任务之前停止其正在进行的一切，有效地中止其当前的操作。但是，没有任何语言方面的需求一个被中断的线程应该终止。中断一个线程只是为了引起该线程的注意，被中断线程可以决定如何应对中断。
此外，虽然 Thread.stop 确实停止了一个正在运行的线程，但是这种方式是不安全的，可能会产生不可预料的结果，在 JDK 中已标记为过时方法。
在 Java 中，每一个线程都有一个中断标志位，该标志位用于表示线程的中断状态：已中断、未中断。
在 java.lang.Thread 中提供了检查、清除和设置中断标识的方法。
/**
* Tests if some Thread has been interrupted. The interrupted state
* is reset or not based on the value of ClearInterrupted that is
* passed.
*/
private native boolean isInterrupted(boolean ClearInterrupted);java.lang.Thread#isInterrupted(boolean) 是一个 native 方法，用于检查线程是否已中断，入参 ClearInterrupted 用于控制是否清除中断状态。
调用该 native 方法的具有以下两个：
Thread#isInterrupted 检查指定线程的中断状态，不清除该线程的中断状态。
/**
* Tests whether this thread has been interrupted. The <i>interrupted
* status</i> of the thread is unaffected by this method.
*
* <p>A thread interruption ignored because a thread was not alive
* at the time of the interrupt will be reflected by this method
* returning false.
*
* @return <code>true</code> if this thread has been interrupted;
* <code>false</code> otherwise.
* @see #interrupted()
* @revised 6.0
*/
public boolean isInterrupted() {
return isInterrupted(false);
}Thread#interrupted 检查当前线程的中断状态，并清除当前线程的中断状态。
/**
* Tests whether the current thread has been interrupted. The
* <i>interrupted status</i> of the thread is cleared by this method. In
* other words, if this method were to be called twice in succession, the
* second call would return false (unless the current thread were
* interrupted again, after the first call had cleared its interrupted
* status and before the second call had examined it).
*
* <p>A thread interruption ignored because a thread was not alive
* at the time of the interrupt will be reflected by this method
* returning false.
*
* @return <code>true</code> if the current thread has been interrupted;
* <code>false</code> otherwise.
* @see #isInterrupted()
* @revised 6.0
*/
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}也就是说，threadA 执行 threadB.interrupt()，则 threadB 会出现以下两种结果之一（取决于 threadB 自身）：
java.lang.Thread#interrupt
/**
* Interrupts this thread.
*
* @throws SecurityException
* if the current thread cannot modify this thread
*
* @revised 6.0
* @spec JSR-51
*/
public void interrupt() {
if (this != Thread.currentThread())
checkAccess();
synchronized (blockerLock) {
Interruptible b = blocker;
if (b != null) {
interrupt0(); // Just to set the interrupt flag
b.interrupt(this);
return;
}
}
interrupt0();
}
private native void interrupt0();已知线程调用 Object#wait、Thread#join、Thread#sleep 方法进入等待状态时，会被其他线程调用 Thread#interrupt 唤醒。
此时当前线程的中断状态会被清除，并抛出 InterruptedException。
如果当前线程处于某种原因无法传递 InterruptedException 异常，最好通过再次调用 interrupt 来恢复中断的状态，以供上层调用者处理。
错误的处理方式：
void func() {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// nothing
}
}正确的处理方式：
void func() throw InterruptedException {
Thread.sleep(50);
}或者
void func() {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}如果在循环中调用 sleep，除非正确地处理中断异常，否则不要去检测中断状态。
错误的处理方式：
@Test
public void dealInterrupt() {
Thread subThread = new Thread(new Runnable() {
@Override
public void run() {
int i = 0;
while (!Thread.currentThread().isInterrupted()) { // 循环检查中断状态
try {
System.out.println(Thread.currentThread().getName() + " 开始第【" + i + "】休眠...");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " 结束第【" + i + "】休眠...");
++i;
} catch (InterruptedException e) { // 如果调用sleep受阻，会抛出异常，同时中断状态true将被清除为false
System.out.println(Thread.currentThread().getName() + " " + e.getMessage());
// 只要正确地处理中断，也可以让循环停止。
// Thread.currentThread().interrupt();
}
}
}
});
subThread.start();
// 主线程执行一段时间，中断子线程，再继续观察子线程一段时间
try {
Thread.sleep(1000);
subThread.interrupt();
Thread.sleep(5000);
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + " " + e.getMessage());
}
}该例子会出现两种执行结果：
如果子线程在休眠当中被中断，由于会清除中断状态，导致子线程会无限循环下去。
Thread-0 开始第【0】休眠...
Thread-0 sleep interrupted
Thread-0 开始第【0】休眠...
Thread-0 结束第【0】休眠...
Thread-0 开始第【1】休眠...
Thread-0 结束第【1】休眠...
Thread-0 开始第【2】休眠...
Thread-0 结束第【2】休眠...
Thread-0 开始第【3】休眠...
Thread-0 结束第【3】休眠...
Thread-0 开始第【4】休眠...
Thread-0 结束第【4】休眠...
Thread-0 开始第【5】休眠...如果子线程在休眠过后被中断，由于会设置中断状态，子线程可以得到终止。
Thread-0 开始第【0】休眠...
Thread-0 结束第【0】休眠...正确的处理方式：
@Test
public void dealInterrupt02() {
Thread subThread = new Thread(new Runnable() {
@Override
public void run() {
int i = 0;
boolean isLoop = true;
while (isLoop) { // 使用自定的循环控制标识
try {
System.out.println(Thread.currentThread().getName() + " 开始第【" + i + "】休眠...");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " 结束第【" + i + "】休眠...");
++i;
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + " " + e.getMessage());
isLoop = false;
}
}
}
});
subThread.start();
// 主线程执行一段时间，中断子线程，再继续观察子线程一段时间
try {
Thread.sleep(1000);
subThread.interrupt();
Thread.sleep(5000);
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + " " + e.getMessage());
}
}new Thread() 会在内存中创建 Thread 类实例，而 new Thread().start() 才会创建并启动操作系统原生线程。作者：Sumkor
链接：https://segmentfault.com/a/11...
你在使用消息队列的时候关注过吞吐量吗？ 思考过吞吐量的影响因素吗？ 考虑过怎...
命令简介 accton 命令是 Linux 系统进程管理命令之一，它的作用是打开进程统计，...
Vue3 发布已经有一段时间了，最近也有机会在公司项目中用上了 Vue3 + TypeScript...
当我们要在域名A.com下使用一个域名B.com提供的页面服务，直觉想到的实现方式就...
作者 Arghya Ghosh 翻译 New Frontend 转载推荐：项目无论是用于自己的应用，还...
前言 Vue Router 是 Vue.js 官方的路由管理器。 它和 Vue.js 的核心深度集成，让...
实现在持续集成环境中为您的应用运行测试的能力，是确保产品质量的重要一步。然...
需求 证件照在我们生活中也是随时都需要的，例如去办证、体检、或者是参加考试等...
现在许多移动手机端都有底部tab栏切换的功能，最近恰巧也做到类似的功能，废话不...
众所周知，不管是Flutter还是uni-app，其实都是一个UI框架，他们都是运行在原生...
