多线程-（一）-多线程概述-优快云博客

进程（英语：process），是指计算机中已运行的程序。进程为曾经是分时系统的基本运作单位。在面向进程设计的系统（如早期的UNIX，Linux 2.4及更早的版本）中，进程是程序的基本执行实体；在面向线程设计的系统（如当代多数操作系统、Linux 2.6及更新的版本）中，进程本身不是基本运行单位，而是线程的容器。程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。若干进程有可能与同一个程序相关系，且每个进程皆可以同步（循序）或异步（平行）的方式独立运行。现代计算机系统可在同一段时间内以进程的形式将多个程序加载到存储器中，并借由时间共享（或称时分复用），以在一个处理器上表现出同时（平行性）运行的感觉。同样的，使用多线程技术（多线程即每一个线程都代表一个进程内的一个独立执行上下文）的操作系统或计算机体系结构，同样程序的平行线程，可在多CPU主机或网络上真正同时运行（在不同的CPU上）。

线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。

线程是独立调度和分派的基本单位。线程可以为操作系统内核调度的内核线程，如Win32线程；由用户进程自行调度的用户线程，如Linux平台的POSIX Thread；或者由内核与用户进程，如Windows 7的线程，进行混合调度。

同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈（call stack），自己的寄存器环境（register context），自己的线程本地存储（thread-local storage）。

一个进程可以有很多线程，每条线程并行执行不同的任务。

在多核或多CPU，或支持Hyper-threading的CPU上使用多线程程序设计的好处是显而易见，即提高了程序的执行吞吐率。在单CPU单核的计算机上，使用多线程技术，也可以把进程中负责I/O处理、人机交互而常被阻塞的部分与密集计算的部分分开来执行，编写专门的workhorse线程执行密集计算，从而提高了程序的执行效率。

在我们的电脑上，也可以直观的观察到线程与进程，打开我们的任务管理器。

任务管理器中的这三条分别是谷歌，TIM与微信程序的进程，我在TIM中打开两个聊天窗口，就会看见TIM的线程中有我打开的两个聊天窗口的线程，如下图

2 使用多线程

有三种方式创建多线程：

1 继承Thread类

代码如下：

package com.example.demo;

/**
 * @Author: Java小学森
 * @Date: 2019/3/7 2:05
 * @Description:
 **/
public class testThread  extends Thread{
    private String threadNm;
    public testThread(String threadNm) {
        this.threadNm = threadNm;
    }
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(threadNm + "线程显示:" + i);
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

class Main {
    public static void main(String[] args) {
        testThread thread1 = new testThread("A");
        testThread thread2 = new testThread("B");
        thread1.start();
        thread2.start();

    }
}

2 实现Runnable接口

代码如下：

package com.example.demo;

import static java.lang.Thread.sleep;

/**
 * @Author: Java小学森
 * @Date: 2019/3/7 2:05
 * @Description:
 **/
public class testThread implements  Runnable {
    private String threadNm;
    public testThread(String threadNm) {
        this.threadNm = threadNm;
    }
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(threadNm + "线程显示:" + i);
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

class Main {
    public static void main(String[] args) {
        testThread thread1 = new testThread("A");
        testThread thread2 = new testThread("B");
        new Thread(thread1).start();
        new Thread(thread2).start();

    }
}

3 实现Callable接口通过FutureTask包装器来创建Thread线程

代码如下：

package com.example.demo;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

import static java.lang.Thread.sleep;

/**
 * @Author: Java小学森
 * @Date: 2019/3/7 2:05
 * @Description:
 **/
public class testThread implements Callable {
    private String threadNm;
    public testThread(String threadNm) {
        this.threadNm = threadNm;
    }
    public Object call() {
        for (int i = 0; i < 5; i++) {
            System.out.println(threadNm + "线程显示:" + i);
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        return null;
    }
}

class Main {
    public static void main(String[] args) {
        Callable callableA = new testThread("A");
        Callable callableB = new testThread("B");
        FutureTask futureTaskA = new FutureTask(callableA);
        FutureTask futureTaskB = new FutureTask(callableB);
        Thread threadA = new Thread(futureTaskA);
        Thread threadB = new Thread(futureTaskB);
        threadA.start();
        threadB.start();
    }
}