多线程——（一）理论知识

一、并发和并行

并发和并行是即相似又有区别(微观概念)：
并行：指两个或多个事件在同一时刻点发生。
并发：指两个或多个事件在同一时间段内发生。

---

在操作系统中，在多道程序环境下，并发性是指在一段时间内宏观上有多个程序在同时运行，但在单CPU系统中，每一时刻却仅能有一道程序执行（时间片），故微观上这些程序只能是分时地交替执行。
倘若计算机系统中有多个CPU，则这些可以并发执行的程序便可被分配到多个处理器上，实现多任务并行执行，即利用每个处理器来处理一个可并发执行的程序，这样，多个程序便可以同时执行，因为是微观的，所以大家在使用电脑的时候感觉就是多个程序是同时执行的。
所以，大家买电脑的时候喜欢买“核”多的，其原因就是“多核处理器”电脑可以同时并行地处理多个程序，从而提高了电脑的运行效率。单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。
同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

---

*：时间片即CPU分配给各个程序的运行时间(很小的概念)。

二、进程和线程

进程是指一个内存中运行中的应用程序。每个进程都有自己独立的一块内存空间，一个应用程序可以同时启动多个进程。比如在Windows系统中，一个运行的abc.exe就是一个进程。
但是问题来了，要是要设计一个植物大战僵尸游戏，如果我们使用多进程模式开发，我们需要开启n个进程才能完成多个功能，这样的设计显然是不合理的。更何况大多数操作系统都不需要一个进程访问其他进程的内存空间，也就是说进程之间的通信很不方便。
此时我们得引入“线程”这门技术，来解决这个问题。
线程是指进程中的一个执行任务(控制单元)，一个进程可以同时并发运行多个线程，如：多线程下载软件。多任务系统,该系统可以运行多个进程,一个进程也可以执行多个任务,一个进程可以包含多个线程。

一个进程至少有一个线程，为了提高效率，可以在一个进程中开启多个执行任务,即多线程。
多进程：操作系统中同时运行的多个程序。
多线程：在同一个进程中同时运行的多个任务。

---

进程与线程的区别：
进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。
线程：堆空间是共享的，栈空间是独立的，线程消耗的资源也比进程小，相互之间可以影响的，又称为轻型进程或进程元。
因为一个进程中的多个线程是并发运行的，那么从微观角度上考虑也是有先后顺序的，那么哪个线程执行完全取决于CPU调度器(JVM来调度)，程序员是控制不了的。

我们可以把多线程并发性看作是多个线程在瞬间抢CPU资源，谁抢到资源谁就运行，这也造就了多线程的随机性。Java程序的进程(Java的一个程序运行在系统中)里至少包含主线程和垃圾回收线程(后台线程)。

三、线程调度

计算机通常只有一个CPU时,在任意时刻只能执行一条计算机指令,每一个进程只有获得CPU的使用权才能执行指令，所谓多进程并发运行,从宏观上看,其实是各个进程轮流获得CPU的使用权,分别执行各自的任务。那么,在可运行池中,会有多个线程处于就绪状态等到CPU,JVM就负责了线程的调度.JVM采用的是抢占式调度,没有采用分时调度,因此可以能造成多线程执行结果的的随机性。

多线程优势:

多线程作为一种多任务、并发的工作方式，当然有其存在优势：
① 进程之前不能共享内存，而线程之间共享内存(堆内存)。
② 系统创建进程时需要为该进程重新分配系统资源,创建线程则代价小很多,因此实现多任务并发时,多线程效率更高.
③ Java语言本身内置多线程功能的支持,而不是单纯第作为底层系统的调度方式,从而简化了多线程编程.

---

多线程下载:可以理解为一个线程就是一个文件的下载通道，多线程也就是同时开起好几个下载通道。当服务器提供下载服务时，使用下载者是共享带宽的，在优先级相同的情况下，总服务器会对总下载线程进行平均分配。

不难理解，如果你线程多的话，那下载的越快。现流行的下载软件都支持多线程。

多线程是为了同步完成多项任务，不是为了提供程序运行效率，而是通过提高资源使用效率来提高系统的效率。

    *：宽带带宽是以位（bit）计算，而下载速度是以字节（Byte）计算，1字节（Byte）等于8位（bit），所以1024kb/s是代表上网带宽为1024千位（1M），而下载速度需要1024千位/秒（1024kb/s）带宽除以8，得出128千字节/秒（128KB/s）。

理论知识过一遍，接下来我们来敲代码，演示一下进程的和线程

四、创建进程

Java操作进程:
在Java代码中如何去运行一个进程(简单讲解,获取进程中的数据(IO)).
方式1:Runtime类的exec方法:
方式2:ProcessBuilder的start方法:

---

代码演示：

package demo;

import java.io.IOException;

//在java中开启进程：运行记事本程序
public class ProcessDemo {
public static void main(String[] args) throws IOException {
//方法1：使用Runtime类的exec()方法
Runtime rt = Runtime.getRuntime();
rt.exec(“notepad”);

    //方法2：ProcessBuilder的start()方法
    ProcessBuilder pb = new ProcessBuilder("notepad");
    pb.start();
}

}

五、创建线程

我们来讲一个例子引入，我们来模拟一个播放器，现在的播放器都可以支持边下载边观看，我们就来模拟这个播放器，在没有引入线程概念的时候，我们来演示一下

代码演示：

package demo;

public class Player {
public static void main(String[] args) {
download();
play();
}

private static void download() {
    for (int i = 0; i <= 100; i++) {
        System.out.println("正在下载..."+i+"%");
    }
}

private static void play() {
    for (int i = 0; i <= 100; i++) {
        System.out.println("正在播放..."+i+"%");
    }
}

}
代码讲解：我们可以看到，没有线程的控制下，我们的例子只能是单线程运行，即下载完了，才能播放，这也符合程序顺序执行的理念，但却不满足我们边下载边播放的情况，所以我们引入的多线程的概念，让下载和播放能够并发执行。

创建和启动线程,传统有两种方式:

方式1：继承Thread类;
方式2：实现Runnable接口;

---

线程类(java.lang.Thread): Thread类和Thread的子类才能称之为线程类. 阅读API.
别忘了主线程(mainf方法运行,表示主线程).

方式1：继承Thread类:

步骤:
1):定义一个类A继承于java.lang.Thread类.
2):在A类中覆盖Thread类中的run方法.
3):我们在run方法中编写需要执行的操作—->run方法里的,线程执行体.
4):在main方法(线程)中,创建线程对象,并启动线程.
创建线程类对象: A类 a = new A类();
调用线程对象的start方法: a.start();//启动一个线程

注意:千万不要调用run方法,如果调用run方法好比是对象调用方法,依然还是只有一个线程,并没有开启新的线程.

代码演示：

package demo;

class Download extends Thread{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
System.out.println(“正在下载…”+i+”%”);
}
}
}

class Play extends Thread{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
System.out.println(“正在播放…”+i+”%”);
}
}
}
public class ExtendsThreadPlayer {
public static void main(String[] args) {
Thread th1 = new Download();
Thread th2 = new Play();
th1.start();
th2.start();
}
}
代码讲解：此时我们就能看到，程序为我们启动了两个线程，并且两个线程是抢占式的方式，来获取CPU的时间片，达到了我们想要的交替运行效果，多次运行，我们能够发现每次结果都不一样，说明线程的时间片分配是随机的。

方式2：实现Runnable接口：

步骤:
1):定义一个类A实现于java.lang.Runnable接口,注意A类不是线程类.
2):在A类中覆盖Runnable接口中的run方法.
3):我们在run方法中编写需要执行的操作—->run方法里的,线程执行体.
4):在main方法(线程)中,创建线程对象,并启动线程.
创建线程类对象: Thread t = new Thread(new A());
调用线程对象的start方法: t.start();

代码演示：

package demo;

class Download implements Runnable{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
System.out.println(“正在下载…”+i+”%”);
}
}
}

class Play implements Runnable{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
System.out.println(“正在播放…”+i+”%”);
}
}
}

public class ImplementsRunnablePlayer {
public static void main(String[] args) {
Runnable target1 = new Download();
Runnable target2 = new Play();
Thread th1 = new Thread(target1);
Thread th2 = new Thread(target2);
th1.start();
th2.start();
}
}
代码讲解：Thread构造器,需要Runnable对象/Runnable实现类的对象。上述例子，我们创建了Runnable对象，然后调用Thread类的有参构造器，来接收Runnable对象，并运行，同样可以完成我们需要的多线程效果。

方法3：使用匿名内部类来创建线程:

只适用于某一个类只使用一次的情况.

代码演示：

package demo;

public class InnerClassThread {
public static void main(String[] args) {
for (int i = 0; i <= 100; i++) {
System.out.println(“正在下载…”+i+”%”);
if(i==10){
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
System.out.println(“正在播放…”+i+”%”);
}
}
}).start();
}
}
}
}
代码讲解：不要忘记，我们的main()方法也是一个线程，所以我们同样可以在main方法中模拟一个线程，先下载10次，当10后，我们启动播放的线程，再让程序双线程交替执行。同样，还可以使用Thread类来创建

代码演示：

package demo;

public class InnerClassThread {
public static void main(String[] args) {
for (int i = 0; i <= 100; i++) {
System.out.println(“正在下载…”+i+”%”);
if(i==10){
new Thread(){
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
System.out.println(“正在播放…”+i+”%”);
}
}
}.start();
}
}
}
}