问题描述:
预先创建了30个线程(DemoThread
),循环启动(start)线程去执行方法,方法的代码上加了ReentrantLock
公平锁;Windows 和 Linux 测试效果如下:
既然是按着顺序启动(start)的线程,方法的执行也加上了公平锁,结果为什么只有 Linux 是按着0-29的顺序在输出呢?
原因分析:
1、Thread.start() 和 Thread.run()
这两个方法作用就是执行线程的 run 方法中的代码,但是本质上有很大的区别。
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();
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();
start() 是一个synchronized
修饰的方法,最终是调用了一个start0()
的native
方法,此时会执行以下步骤:
-
通过JVM告诉操作系统创建一个Thread;
-
操作系统开辟内存,并通过创建 Thread 线程对象;
-
操作系统对 Thread 对象进行调度,并确定执行时间;
-
Thread 在操作系统中被执行;
以上过程,主线程(main)并不需要等待 Thread 执行完毕,而是直接往后继续执行了;至于对 Thread 的调度,什么时候执行,就完全交由系统根据自己的CPU竞争策略来决定,跟主线程(main)、调用 start 方法的顺序没有任何关系了;
CPU 竞争策略
那上面的测试输出,为什么最终执行的结果看起来只有Windows乱了呢?
这是由于两个操作系统采用了不同的 CPU 竞争策略,Linux系统使用的是时间片算法,Windows则属于抢占式。这两种策略最终会带来不同的线程执行顺序;
时间片算法
在时间片算法中,所有的进程排成一个队列。操作系统按照他们的顺序,给每个进程分配一段时间,即该进程允许运行的时间。如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程。
如果进程在时间片结束前阻塞或结束,则CPU当即进行切换。调度程序所要做的就是维护一张就绪进程列表,当进程用完它的时间片后,它被移到队列的末尾。
抢占式操作系统
所谓抢占式操作系统,就是说如果一个进程得到了 CPU 时间,除非它自己放弃使用 CPU ,否则将完全霸占 CPU 。因此可以看出,在抢占式操作系统中,操作系统假设所有的进程都是“人品很好”的,会主动退出 CPU 。
在抢占式操作系统中,假设有若干进程,操作系统会根据他们的优先级、饥饿时间(已经多长时间没有使用过 CPU 了),给他们算出一个总的优先级来。操作系统就会把 CPU 交给总优先级最高的这个进程。
当进程执行完毕或者自己主动挂起后,操作系统就会重新计算一 次所有进程的总优先级,然后再挑一个优先级最高的把 CPU 控制权交给他。
相比下来,抢占式就有点像野蛮人;这也就解释了 Windows 为什么每次输出的结果都不太一样;由于测试用例执行的内容并不复杂,Linux 在最开始的时候,同一时间片下,就能执行完所有的指令,因此看起来就像线程是有序的在执行,当线程多导致同一时间片无法完成之后,同样也会出现错乱,但相比 Windows 更加有规律;
以下是 200 个线程的执行结果:
所以,不管是 Windows 还是 Linux,最终执行 run 方法的顺序跟线程调用start() 顺序并不是一致,不能通过 start() 方法来决定线程的执行顺序;跟 ReentrantLock 公平锁就更没有任何关系了;
Thread.run()源码如下:
/**
* 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();
}
}
只有当线程创建时,传入了Runnable
对象,调用此方法才会有效,而且执行的过程并不是一个异步任务,不会交给“线程规划器”来管理,是由调用 run()
方法的主线程(main)在执行;通过 Thread.run() 执行的代码,是可以保证线程的执行顺序的,但是多线程的执行过程就由并行变成了串行化,也就是说,线程1执行完在执行线程2,线程2执行完才会轮到线程3 .... 一直到最后一个线程;这样就失去了多线程的意义了,因此, Thread.run()
在实际开发中要酌情使用。
2、线程的有序执行
2.1、join(),join方法是Thread类中的一个方法,作用是等待该线程执行直到终止。
public class ThreadTest {
public static void main(String[] args) throws Exception{
Thread t1 = new Thread(()-> System.out.println(Thread.currentThread().getName()+ "线程1"));
Thread t2 = new Thread(()-> System.out.println(Thread.currentThread().getName()+ "线程2"));
Thread t3 = new Thread(()-> System.out.println(Thread.currentThread().getName()+ "线程3"));
t1.start();
t1.join();
t2.start();
t2.join();
t3.start();
}
}
2.2、FutureTask,利用 get() 方法阻塞等待返回,只有执行完之后,才会继续往后执行;
public static void futureTask() throws Exception{
FutureTask<String> f1 = new FutureTask<>(() -> {
System.out.println(Thread.currentThread().getName() + " FutureTask1");
return "FutureTask1";
});
FutureTask<String> f2 = new FutureTask<>(() -> {
System.out.println(Thread.currentThread().getName() + " FutureTask2");
return "FutureTask2";
});
FutureTask<String> f3 = new FutureTask<>(() -> {
System.out.println(Thread.currentThread().getName() + " FutureTask3");
return "FutureTask3";
});
Thread t1 = new Thread(f1,"线程1");
Thread t2 = new Thread(f2,"线程2");
Thread t3 = new Thread(f3,"线程3");
t1.start();
System.out.println(f1.get());
t2.start();
System.out.println(f2.get());
t3.start();
System.out.println(f3.get());
}
2.3、单线程池,单线程池同一时间只允许有一个线程在执行,因此可以将要执行的线程按顺序提交给线程池,就能实现顺序执行的效果;
public static void singleThreadExecutor() {
ExecutorService threadPool = Executors.newSingleThreadExecutor();
Thread t1 = new Thread(() -> System.out.println(Thread.currentThread().getName() + " 线程1"));
Thread t2 = new Thread(() -> System.out.println(Thread.currentThread().getName() + " 线程2"));
Thread t3 = new Thread(() -> System.out.println(Thread.currentThread().getName() + " 线程3"));
threadPool.execute(t1);
threadPool.execute(t2);
threadPool.execute(t3);
threadPool.shutdown();
}
2.4、CountDownLatch,利用 CountDownLatch 的 await() 阻塞方法,后一个线程只有等前一个线程执行完并调用countDown()
,才能继续执行;
public static void countDownLatch() {
CountDownLatch c1 = new CountDownLatch(1);
CountDownLatch c2 = new CountDownLatch(1);
Thread t1 = new Thread(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 线程1 等待1000ms");
c1.countDown();
});
Thread t2 = new Thread(() -> {
try {
c1.await();
System.out.println(Thread.currentThread().getName() + " 线程2");
} catch (InterruptedException e) {
e.printStackTrace();
}
c2.countDown();
});
Thread t3 = new Thread(() -> {
try {
c2.await();
System.out.println(Thread.currentThread().getName() + " 线程3");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
t1.start();
t2.start();
t3.start();
}