Java技术栈——Java多线程详述

一.多线程

1.1多线程概述

    在了解学习多线程之前，我们先要熟悉了解几个关于多线程有关的概念。
进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

    简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程。什么是多线程呢？ 多线程定义:在一个程序中,这些独立运行的程序片段叫作“线程”。即就是一个程序中有多个线程在同时执行。

    我们可以通过程序执行流程，来区分单线程程序与多线程程序的不同：
单线程程序：即，若有多个任务只能依次执行。当上一个任务执行结束后，下一个任务开始执行。如接水，有一个水龙头，一个人接完，下一个人才能开始接水。
多线程程序：即，若有多个任务可以同时执行。如在饮水机处接水，温水处与热水处可以同时放水。

1.2 程序运行原理

分时调度：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。分时调度可以在分时调度类中公平地分布处理资源。内核的其他部分可以在短时间内独占处理器，而不会缩短用户察觉的响应时间。在Java中可以设置一个或多个进程的优先级级别，优先级的级别范围通常为 0 到 +10（不指定的话，java默认创建为5），值越低，优先级越高。
抢占式调度：这里有必要说明一下，抢占式调度是实时调度的一种。优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

1.2.1 抢占式调度详解

    现在大部分电脑操作系统都支持多进程并发运行，即支持多个软件同时运行，比如打开了微信，并且同时听着某易音乐，然后在CSDN上编写分享博客，“感觉上，这些运用在同时进行。”实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换（针对于某一个核来说），我们根本就没有察觉到，对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。所以，仔细想想就会发现，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

1.3 主线程

    再来看看我们最开始之前，学习常用的场景，当我们在dos命令行中输入java空格类名回车后，启动JVM，并且加载对应的class文件。虚拟机并会从main方法开始执行我们的程序代码，一直把main方法的代码执行完成。如果在执行过程遇到循环时间比较长的代码，那么在循环之后的其他代码是不会被马上执行的。如下代码演示：

class Demo{
    
    
	String name;
	Demo(String name){
    
    	
		this.name = name;
	}

	void show() {
    
    
		for (int i=1;i<=10000 ;i++ ) {
    
    
			System.out.println("name="+name+",i="+i);
		}
	}
}
class ThreadDemo {
    
    
	public static void main(String[] args) {
    
    
    	Demo demo = new Demo("CSDN");
		Demo demo2 = new Demo("NDSC");
		demo.show();
		demo2.show();
	}
}

    若在上述代码中show方法中的循环执行次数很多，这时在demo.show();下面的代码是不会马上执行的，并且在dos窗口会看到不停的输出name=CSDN,i=++，这样的语句。是因为：jvm启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束，这个线程在java中称之为主线程。当程序的主线程执行时，如果遇到了循环而导致程序在指定位置停留时间过长，则无法马上执行下面的程序，需要等待循环结束后能够执行。
    那么，能否实现一个主线程负责执行其中一个循环，再由另一个线程负责其他代码的执行，最终实现多部分代码同时执行的效果？当然可以，Java中的多线程技术能够实现同时执行。

1.4 Thread类

    该如何创建线程呢？通过API中搜索，查到Thread类。通过阅读Thread类中的描述，我们能够了解到Thread是程序中的执行线程，并且Java 虚拟机是支持并允许应用程序并发地运行多个执行线程。
构造方法

Thread（）构造方法摘要	描述
Thread()	分配线程对象
Thread(String name)	分配新的线程对象，将指定的name作为其线程名称

常用方法

类型	名称	描述
void	start()	使该线程开始执行；Java虚拟机实际上调用的是该线程的run()方法
void	run()	该线程具体要执行的操作
static void	sleep(long m)	让当前正在执行的线程休眠毫秒，（暂停执行）

1.5 创建线程

    创建新执行线程有两种方法。
继承Thread：将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。创建对象，开启线程。run方法相当于其他线程的main方法。
继承Thread创建线程的步骤：
1 定义一个类继承Thread。
2 重写run方法。
3 创建子类对象，就是创建线程对象。
4 调用start方法，开启线程并让线程执行，此时jvm会去调用run方法。

实现Runnable：声明一个实现 Runnable 接口的类，该类会实现 run 方法，然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。

main

//测试类
public class Demo {
    
    
	public static void main(String[] args) {
    
    
		ThreadDemo td = new ThreadDemo("线程Demo！");
		//开启新线程
		td.start();
		//在主方法中执行for循环
		for (int i = 0; i < 10; i++) {
    
    
			System.out.println("main线程！"+i);
		}
	}
}

新建线程类

//新建线程类
public class ThreadDemo extends ThreadDemo {
    
    
	public ThreadDemo (String name) {
    
    
	//调用父类的String参数的构造方法，指定线程的名称
		super(name);
	}
	//重写run方法
	@Override
	public void run() {
    
    
		for (int i = 0; i < 10; i++) {
    
    
			System.out.println(getName()+"：正在执行！"+i);
		}
	}
}

1.5.1 run()与start()

注意：线程对象调用 run方法和调用start方法区别？
    在理解这个问题之前，我们应该清楚什么是run()方法，什么是start()方法；
run()：就是继承Thread类，或者实现runnable要实现的方法，本质上是一个成员函数，但并不是多线程的方式，就是一个普通的方法。我们从源码就能看出就是简单的普通方法的调用。
run()源码

    @Override
    public void run() {
    
    
     // 简单的运行，不会新起线程，target 是 Runnable
        if (target != null) {
    
    
            target.run();
        }
    }

start()：要理解start方法，我们最好从源码入手，start 方法的源码也没几行代码，注释也比较详细，最主要的是 start0() 方法。
start()源码

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() 是启动多线程的关键
     // 这里会创建一个新的线程，是一个 native 方法
     // 执行完成之后，新的线程已经在运行了
        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 */
        }
    }
}

start0()源码

private native void start0();

    start0()的源码只有一行，为了方便理解start执行过程以及日后的学习，总结了start0的每一步调用执行过程。

• Step1:：start0方法实际上调用的是jvm.cpp文件的JVM_StartThread方法，（是否创建线程，以及能否创建线程，比如内存已满，无法继续创建新的线程，都是在这一步进行判断的）；
• Step2：如果能创建，则调用JavaThread方法创建线程（包括初始化相关变量），就在创建线程的时候，传入了java_start,做为线程运行函数的初始地址；
• Step3：当子线程完成初始化之后，父线程会执行Thread::start方法，设置线程状态为RUNNABLE；
• Step4：这时候子线程就可以开始执行thread->run()方法了。
  

    补充：start0为什么会被标记成native本地方法。众所周知，Java其最大的优点之一就是跨平台性，start() 方法调用 start0() 方法后，该线程并不一定会立马执行，只是将线程变成了可运行状态（NEW —> RUNNABLE）。具体什么时候执行，取决于 CPU ，由 CPU 统一调度。可以在不同系统上运行，每个系统的 CPU 调度算法不一样，所以就需要做不同的处理，这件事情就只能交给 JVM 来实现了，start0() 方法自然就表标记成了 native。
    所以综上，线程对象调用run方法不开启线程，仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。

1.5.2 继承Thread类原理

    我们为什么要继承Thread类，并调用其的start方法才能开启线程呢？继承Thread类：因为Thread类用来描述线程，具备线程应该有的功能。那为什么不直接创建Thread类的对象呢？如下代码：

Thread t1 = new Thread();
//这样做没有错，但是该start调用的是Thread类中的run方法
//这个run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让线程执行的代码。
t1.start();

    创建线程是为了建立程序单独的执行路径，让多部分代码实现同时执行。也就是说线程创建并执行需要给定线程要执行的任务。对于之前所讲的主线程，它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。Thread类run方法中的任务并不是我们所需要的，只有重写这个run方法。既然Thread类已经定义了线程任务的编写位置（run方法），那么只要在编写位置（run方法）中定义任务代码即可。所以进行了重写run方法动作。

1.5.3 多线程的内存图解

    多线程执行时，在内存中的运行方式其实很简单：多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

1.5.4 获取线程名称

    开启的线程都会有自己的独立运行栈内存，而这些线程都是有其默认的名字的，当然也可以自定义线程名。根据Thread类的API文档整理如下。

函数名	功能
Thread.currentThread()	获取当前线程对象
Thread.currentThread().getName()	获取当前线程对象的名称

class MyThread extends Thread {
    
     
   MyThread(String name){
    
    
   	super(name);
   }
   //复写其中的run方法
   public void run(){
    
    
   	for (int i=1;i<=100 ;i++ ){
    
    
   		System.out.println(Thread.currentThread().getName()+",i="+i);
   	}
   }
}

class ThreadDemo {
    
    
   public static void main(String[] args) {
    
    
   	//创建两个线程任务
   	MyThread d = new MyThread();
   	MyThread d2 = new MyThread();
   	//没有开启新线程, 在主线程调用run方法
   	d.run();
   	//开启一个新线程，新线程调用run方法
   	d2.start();
   }
}

    通过结果观察，原来主线程的名称：main；自定义的线程：Thread-0，线程多个时，数字顺延。如Thread-1…注意：进行多线程编程时，不要忘记了Java程序运行是从主线程开始，main方法就是主线程的线程执行内容。

1.6 创建线程方式—实现Runnable接口

    创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。查看Runnable接口说明文档：Runnable接口用来指定每个线程要执行的任务。包含了一个 run 的无参数抽象方法，需要由接口实现类重写该方法。
实现Runnable接口，创建线程的步骤：

• 1、定义类实现Runnable接口。
• 2、覆盖接口中的run方法。。
• 3、创建Thread类的对象
• 4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
• 5、调用Thread类的start方法开启线程。

示例

public class RunnableDemo {
    
    
	public static void main(String[] args) {
    
    
		//创建线程执行目标类对象
		Runnable runnable = new MyRunnable();
		//将Runnable接口的子类对象作为参数传递给Thread类的构造函数
		Thread thread = new Thread(runn);
		Thread thread2 = new Thread(runn);
		//开启线程
		thread.start();
		thread2.start();
		for (int i = 0; i < 10; i++) {
    
    
			System.out.println("main线程：正在执行！"+i);
		}
	}
}

线程执行类示例

public class MyRunnable implements Runnable{
    
    
	@Override
	public void run() {
    
    
		for (int i = 0; i < 100; i++) {
    
    
			System.out.println("线程！"+i);
		}
	}
}

1.6.1 Runnable的优点

    第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

1.7 线程的匿名内部类使用

    使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

• 方式1：创建线程对象时，直接重写Thread类中的run方法

new Thread() {
    
    
	public void run() {
    
    
		for (int i = 0; i < 100; i++) {
    
    
			System.out.println(Thread.currentThread().getName()+ ">>>>" + i);
		}
	}
}.start();

• 方式2：使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法

Runnable runnable = new Runnable() {
    
    
	public void run() {
    
    
		for (int i = 0; i < 100; 1x++) {
    
    
			System.out.println(Thread.currentThread().getName()+ ">>>>" + i);
		}
	}
};
new Thread(runnable ).start();

二、线程池

2.1 线程池概念

    线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
    在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。
    线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。

2.2 使用线程池方式–Runnable接口

    通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。
Executors：线程池创建工厂类

• public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象
• ExecutorService：线程池类
• Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行
• Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

使用线程池中线程对象的步骤，代码示例：

public class ThreadPoolDemo {
    
    
	public static void main(String[] args) {
    
    
	//创建线程池，包含10个线程
	ExecutorService service = Executors.newFixedThreadPool(10);
	RunnableDemo rd = new RunnableDemo ();
	//从线程池中获取线程对象,然后调用RunnableDemo 中的run()
	service.submit(rd);
	//注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中
	//关闭线程池
	//service.shutdown();
	}
}

Runnable接口实现类

public class RunnableDemo implements Runnable {
    
    
	@Override
	public void run() {
    
    
		System.out.println("线程示例启动");
		System.out.println("线程： " +Thread.currentThread().getName());
		System.out.println("线程关闭"+Thread.currentThread().getName());
	}
}

2.3 使用线程池方式—Callable接口

lCallable接口：与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。

• Future submit(Callable task)：获取线程池中的某一个线程对象，并执行线程中的call()方法
• Future接口：用来记录线程任务执行完毕后产生的结果。
  代码示例：

public class ThreadPoolDemo {
    
    
	public static void main(String[] args) {
    
    
		//创建线程池,包含10个线程
		ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
		//创建Callable对象
		CallableDemo cd = new CallableDemo ();
		service.submit(c);
		service.submit(c);		
	}
}

Callable接口实现类,call方法可抛出异常、返回线程任务执行完毕后的结果

public class CallableDemo implements Callable {
    
    
@Override
public Object call() throws Exception {
    
    
	System.out.println("线程示例:call");
	System.out.println("线程： " +Thread.currentThread().getName());
	System.out.println("线程结束："+Thread.currentThread().getName());
	return null;
	}
}