什么是线程？
线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。
线程是独立调度和分派的基本单位。线程可以为操作系统内核调度的内核线程，如Win32线程；由用户进程自行调度的用户线程，如Linux平台的POSIX Thread；或者由内核与用户进程，如Windows 7的线程，进行混合调度。
我们知道，一个线程可以用来执行一个任务，并且该任务的执行是异步的，并不会阻塞后面的代码。在一个java进程中，包含main方法的类也是在一个线程中执行的。在实际应用中，如果需要处理一个比较耗时的操作，为了不影响程序整体的响应，通常会将这个耗时的操作封装到一个线程中，异步的执行。但是，线程是怎样实现任务的异步执行的呢？本文将深入了解Thread类，以期望得出线程执行的秘密。
根据《深入理解JAVA虚拟机》中关于线程的章节，我们得知，在java中一个Thread对应着操作系统中的一个线程。而操作系统的线程是稀缺资源，不能无限制的创建线程，这也就是为什么要使用线程池的原因之一。
我们也知道，在java中要实现一个线程，有两种方式：
但是不管是哪种方式，最后线程的执行还是要通过调用Thread的start()方法
让我们看一下Thread类的重要属性和方法：
// target就是一个传递给Thread等待Thread执行的Runnable对象
/* What will be run. */
private Runnable target;
/* The group of this thread */
private ThreadGroup group;
// 类方法，该方法会在Thread类初始化时，在类的构造器<clinit>中被调用，且只会调用一次，该方法主要的作用是注册一些本地的方法，以便后期可以使用
/* Make sure registerNatives is the first thing <clinit> does. */
private static native void registerNatives();
static {
registerNatives();
}
// 注册了以下本地方法：
public static native Thread currentThread();
public static nativevoid yield();
public static native void sleep(long millis) throws InterruptedException;
private native void start0();
private native boolean isInterrupted(boolean ClearInterrupted);
public final native boolean isAlive();
public static native boolean holdsLock(Object obj);
private native static StackTraceElement[][] dumpThreads(Thread[] threads);
private native static Thread[] getThreads();
private native void setPriority0(int newPriority);
private native void stop0(Object o);
private native void suspend0();
private native void resume0();
private native void interrupt0();
private native void setNativeName(String name);让我们看看下面这段代码将输出什么内容：
public static class MyThread extends Thread{
@Override
public void run(){
System.out.println("MyThread---1");
}
}
public static class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("MyRunnable---1");
}
}
public static void main(String[] args) {
Thread t1 = new MyThread();
Thread t2 = new Thread(new MyRunnable());
t1.start();
t2.start();
System.out.println("MyThread---2");
System.out.println("MyRunnable---2");
}该代码的输出内容是不确定的，可能输出为：
MyThread---2
MyRunnable---2
MyRunnable---1
MyThread---1也可能输出为：
MyThread---1
MyRunnable---1
MyThread---2
MyRunnable---2但是如果把上述的代码t1.start(),t2.start()改为：
t1.run();
t2.run();那么输出将变成确定的：
MyThread---1
MyRunnable---1
MyThread---2
MyRunnable---2为什么使用start()，输出的内容是不确定的，而使用run()输出却是确定的呢？这就需要从Thread的启动过程开始了解了。 Thread类中start()方法的源代码如下：
public synchronized void start() {
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()方法内部其实调用了一个native的方法start0()。而在Thread类初始化时，执行了一个registerNatives()的方法来注册本地方法，其中start0方法实际关联的是JVM_StartThread方法：
{"start0", "()V",(void *)&JVM_StartThread}在 jvm.cpp 中，有如下代码段：
JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread)){
...
native_thread = new JavaThread(&thread_entry, sz);
...
}这里JVMENTRY是一个宏，用来定义JVMStartThread函数，可以看到函数内创建了真正的平台相关的本地线程，其线程函数是thread_entry，如下：
static void thread_entry(JavaThread* thread, TRAPS) {
HandleMark hm(THREAD);
Handle obj(THREAD, thread->threadObj());
JavaValue result(T_VOID);
JavaCalls::call_virtual(&result,obj,KlassHandle(THREAD,SystemDictionary::Thread_klass()),
vmSymbolHandles::run_method_name(), //调用了run_method_name
vmSymbolHandles::void_method_signature(),THREAD);
}可以看到调用了vmSymbolHandles::runmethodname方法，而runmethodname是在vmSymbols.hpp 用宏定义的：
class vmSymbolHandles: AllStatic {
...
// 这里决定了调用的方法名称是 “run”
template(run_method_name,"run")
...
}从以上的代码中可以看出，Thread执行start()方法，首先会创建一个新的操作系统的线程，然后当该操作线程得到CPU时间片时，会执行一个回调方法:run()，这也就证明了通过start()可以创建一个新线程并异步执行线程体，而通过run()只是执行了一个Thread对象的普通方法而已，并不会并行执行，而是串行执行的。
以下附上一些Thread相关的常见性的问题：
public static void main(String[] args){
Thread t1 = new Thread();
t1.start();
t1.join();
// 以下代码会在t1执行完毕后打印
System.out.println("t1 finished");
}wait()和notify()必须操作同一个"对象监视器"
Runnable1 implements Runnable{
public void run(){
synchronized(lock){
// 等待其他线程来唤醒
lock.wait();
System.out.println("Runnable1 has been notified by other thread");
}
}
}
Runnable2 implements Runnable{
public void run(){
synchronized(lock){
System.out.println("Runnable2 will notify other thread who wait for lock");
// 唤醒其他线程 lock.notify();
}
}
}
public static void main(String[] args){
Object lock = new Object();
Thread t1 = new Thread(new Runnable1(lock));
Thread t2 = new Thread(new Runnable2(lock));
t1.start();
t2.start();
}MyRunnable r = new MyRunnable();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
// t1/t2线程操作的都是同一个实例r，所以r中的数据可以实现多线程共享
t1.start();
t2.start();FutureTask<Integer> futureTask = new FutureTask<>(callable);
new Thread(futureTask).start();
Object result = futureTask.get();1) CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：
2) CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；
3) CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；
4) 另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。
5) Semaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限。
线程池有两个参数：核心线程数coreNum和最大线程数maxNum
假设初始化一个线程池，核心线程数是5，最大线程数是10，线程池初始化的时候，里面是没有线程的
当来了一个任务时，就初始化了一个线程，如果再来一个任务，再初始化了一个线程，连续初始化了5个线程之后，如果第6个任务过来了
这时会把第6个任务放到阻塞队列中
现在线程池中有了5个线程，如果其中一个线程空闲了，就会从阻塞队列中获取第6个任务，进行执行
如果线程池的5个线程都在running状态，那么任务就先保存在阻塞队列中
如果队列满了，并且我们设置了最大线程数是10，但线程池中只有5个线程，这时会新建一个线程去执行不能保存到阻塞队列的任务，此时线程池中有了6个线程
如果线程池中的线程数达到10个了，并且阻塞队列也满了，则可以通过自定义的reject函数去处理这些任务
最后运行一段时间之后，阻塞队列中的任务也执行完了，线程池中超过核心线程数的线程会在空闲一段时间内自动回收
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
