线程相关概念

什么是程序(Program)？
程序就是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

什么是进程(Process)？
进程是程序的一次执行过程，或是正在运行的一个程序。

什么是动态过程(Dynamic Process)？
动态过程有它自身的产生、存在和消亡的过程。【程序是静态的，进程是动态的】

什么是线程(Thread)？
在一个进程中执行的一套功能流程，成为线程。

Java多线程

什么是多线程？
在一个进程中执行的多套功能流程，称为多线程。

常见的多线程应用？
Java虚拟机、360安全卫士等等。

多线程程序优点
提高应用程序的响应，对图形化界面更有意义，可增强用户体验；提高计算机系统CPU的利用率；改善程序结构；将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

多线程创建方式

继承Thread类创建线程

声明一个类继承Thread接口；
重写Thread接口中的 run() 方法；
创建该类实例，调用 start() 方法启动线程，默认执行 run() 方法。

/*** 第一种创建线程的方式：*      1：定义一个类，让该类去继承Thread类*      2：重写 run 方法*      3：创建该类的对象*      4：启动线程* */
public class ThreadDemo {public static void main(String[] args) {// 创建线程MyThread t1 = new MyThread();MyThread t2 = new MyThread();// 启动线程：需要使用 start 方法启动线程，如果我们在这里调用的是run方法.// 那么我们只是把该方法作为普通方法进行执行// t1.run();// t2.run();t1.start();     // 告诉jvm开启一个线程调用run方法// t1.start();  // 一个线程只能被启动一次t2.start();}
}
class MyThread extends Thread{@Overridepublic void run() {for (int x = 0 ; x < 1000 ; x++){System.out.println(x);}}
}

如果调用的是 run() 方法，那么则会按顺序执行两遍 run() 方法，只有调用 start() 方法才是开启线程。

实现Runnable接口创建线程

声明一个类实现Runnable接口；
重写Runnable接口中的 run() 方法；
创建Runnable接口实现类的实例，并用这个实例作为Thread的target来创建Thread对象，Thread对象才是真正的线程对象；
调用Thread类的 start() 方法启动线程，默认执行 run() 方法。

/*** 第二种创建线程的方式：*      1：定义一个类，让该类去实现Runnable接口*      2：重写run方法*      3：创建定义的类的对象*      4：创建Thread的对象把第三步创建的对象作为参数传递进来*      5：启动线程* */
public class ThreadDemo2 {public static void main(String[] args) {// 创建定义的类的对象MyThread2 mt = new MyThread2();// 创建Thread对象，将上面的对象传入Thread t1 = new Thread(mt, "张三");Thread t2 = new Thread(mt, "李四");// 启动线程t1.start();t2.start();}
}
class MyThread2 implements Runnable{@Overridepublic void run() {for (int x = 0 ; x < 1000 ; x++){System.out.println(Thread.currentThread() + "---" + x);}}
}

运行效果：（循环次数取50）

Thread[张三,5,main]---0
Thread[张三,5,main]---1
Thread[李四,5,main]---0
Thread[李四,5,main]---1
Thread[李四,5,main]---2
Thread[李四,5,main]---3
Thread[李四,5,main]---4
Thread[李四,5,main]---5
Thread[李四,5,main]---6
Thread[李四,5,main]---7
Thread[张三,5,main]---2
Thread[张三,5,main]---3
Thread[张三,5,main]---4
Thread[李四,5,main]---8
Thread[李四,5,main]---9
Thread[李四,5,main]---10
Thread[李四,5,main]---11
Thread[李四,5,main]---12
Thread[李四,5,main]---13
Thread[李四,5,main]---14
Thread[李四,5,main]---15
Thread[李四,5,main]---16
Thread[李四,5,main]---17
Thread[李四,5,main]---18
Thread[李四,5,main]---19
Thread[李四,5,main]---20
Thread[李四,5,main]---21
Thread[李四,5,main]---22
Thread[李四,5,main]---23
Thread[李四,5,main]---24
Thread[李四,5,main]---25
Thread[张三,5,main]---5
Thread[张三,5,main]---6
Thread[张三,5,main]---7
Thread[张三,5,main]---8
Thread[张三,5,main]---9
Thread[张三,5,main]---10
Thread[张三,5,main]---11
Thread[张三,5,main]---12
Thread[张三,5,main]---13
Thread[张三,5,main]---14
Thread[张三,5,main]---15
Thread[张三,5,main]---16
Thread[张三,5,main]---17
Thread[张三,5,main]---18
Thread[张三,5,main]---19
Thread[张三,5,main]---20
Thread[李四,5,main]---26
Thread[李四,5,main]---27
Thread[李四,5,main]---28
Thread[李四,5,main]---29
Thread[李四,5,main]---30
Thread[李四,5,main]---31
Thread[李四,5,main]---32
Thread[李四,5,main]---33
Thread[李四,5,main]---34
Thread[李四,5,main]---35
Thread[李四,5,main]---36
Thread[张三,5,main]---21
Thread[李四,5,main]---37
Thread[张三,5,main]---22
Thread[张三,5,main]---23
Thread[李四,5,main]---38
Thread[李四,5,main]---39
Thread[张三,5,main]---24
Thread[张三,5,main]---25
Thread[张三,5,main]---26
Thread[张三,5,main]---27
Thread[张三,5,main]---28
Thread[张三,5,main]---29
Thread[张三,5,main]---30
Thread[张三,5,main]---31
Thread[张三,5,main]---32
Thread[张三,5,main]---33
Thread[张三,5,main]---34
Thread[张三,5,main]---35
Thread[张三,5,main]---36
Thread[张三,5,main]---37
Thread[张三,5,main]---38
Thread[李四,5,main]---40
Thread[李四,5,main]---41
Thread[李四,5,main]---42
Thread[李四,5,main]---43
Thread[李四,5,main]---44
Thread[李四,5,main]---45
Thread[李四,5,main]---46
Thread[张三,5,main]---39
Thread[张三,5,main]---40
Thread[张三,5,main]---41
Thread[张三,5,main]---42
Thread[张三,5,main]---43
Thread[张三,5,main]---44
Thread[张三,5,main]---45
Thread[李四,5,main]---47
Thread[张三,5,main]---46
Thread[张三,5,main]---47
Thread[张三,5,main]---48
Thread[李四,5,main]---48
Thread[张三,5,main]---49
Thread[李四,5,main]---49

使用Callable和Future创建线程

Callable基础简介
Runnable 从 JDK1.0 开始就有了，Callable 是在 JDK1.5 增加的。它们的主要区别是 Callable 的 call() 方法可以返回值和抛出异常，而 Runnable 的 run() 方法没有这些功能。Callable 可以返回装载有计算结果的 Future 对象。

通过对比两个接口得到以下结论
Callable 接口下的方法是 call()，Runnable 接口的方法是 run()；
Callable 的任务执行后可返回值，而 Runnable 的任务是不能返回值的；
call() 方法可以抛出异常，run()方法不可以的；
运行 Callable 任务可以拿到一个 Future 对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过 Future 对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果；

Callable创建步骤

创建Callable接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的 call() 方法的返回值。
使用FutureTask对象作为Thread对象的target创建并启动新线程。
调用FutureTask对象的 get() 方法来获得子线程执行结束后的返回值，调用 get() 方法会阻塞线程。

public class CallableAndFuture {// Callable : 一个产生结果// Future : 一个拿到结果public static void main(String[] args){// 1.创建 Callable 的对象返回值Callable<Integer> callable = new Callable<Integer>() {@Overridepublic Integer call() throws Exception {return new Random().nextInt(100);}};// 2.FutureTask 实现了两个接口，Runnable和Future// 所以它既可以作为Runnable被线程执行，// 又可以作为Future得到Callable的返回值FutureTask<Integer> future = new FutureTask<>(callable);// 3.作为Runnable被线程执行new Thread(future).start();try {Thread.sleep(5000); // 可能做一些事// 4.作为Future得到Callable的返回值System.out.println(future.get());} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}
}

public class ThreadDemo3 {public static void main(String[] args) {CallableThread ctt = new CallableThread();FutureTask<Integer> ft = new FutureTask<>(ctt);for (int i = 0 ; i < 50 ; i++){System.out.println(Thread.currentThread().getName() + "的循环变量i的值" + i);if (i == 20){new Thread(ft,"有返回值的线程").start();}}try {System.out.println("子线程的返回值：" + ft.get());} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}
}
class  CallableThread implements Callable<Integer>{@Overridepublic Integer call() throws Exception {int i = 0;for (; i < 59; i++){System.out.println(Thread.currentThread() + "---" + i);}return i;}
}

运行效果：

main的循环变量i的值0
main的循环变量i的值1
main的循环变量i的值2
main的循环变量i的值3
main的循环变量i的值4
main的循环变量i的值5
main的循环变量i的值6
main的循环变量i的值7
main的循环变量i的值8
main的循环变量i的值9
main的循环变量i的值10
main的循环变量i的值11
main的循环变量i的值12
main的循环变量i的值13
main的循环变量i的值14
main的循环变量i的值15
main的循环变量i的值16
main的循环变量i的值17
main的循环变量i的值18
main的循环变量i的值19
main的循环变量i的值20
main的循环变量i的值21
main的循环变量i的值22
main的循环变量i的值23
main的循环变量i的值24
main的循环变量i的值25
main的循环变量i的值26
main的循环变量i的值27
main的循环变量i的值28
main的循环变量i的值29
main的循环变量i的值30
main的循环变量i的值31
main的循环变量i的值32
main的循环变量i的值33
main的循环变量i的值34
main的循环变量i的值35
main的循环变量i的值36
main的循环变量i的值37
main的循环变量i的值38
main的循环变量i的值39
main的循环变量i的值40
Thread[有返回值的线程,5,main]---0
main的循环变量i的值41
main的循环变量i的值42
main的循环变量i的值43
main的循环变量i的值44
main的循环变量i的值45
main的循环变量i的值46
main的循环变量i的值47
main的循环变量i的值48
main的循环变量i的值49
Thread[有返回值的线程,5,main]---1
Thread[有返回值的线程,5,main]---2
Thread[有返回值的线程,5,main]---3
Thread[有返回值的线程,5,main]---4
Thread[有返回值的线程,5,main]---5
Thread[有返回值的线程,5,main]---6
Thread[有返回值的线程,5,main]---7
Thread[有返回值的线程,5,main]---8
Thread[有返回值的线程,5,main]---9
Thread[有返回值的线程,5,main]---10
Thread[有返回值的线程,5,main]---11
Thread[有返回值的线程,5,main]---12
Thread[有返回值的线程,5,main]---13
Thread[有返回值的线程,5,main]---14
Thread[有返回值的线程,5,main]---15
Thread[有返回值的线程,5,main]---16
Thread[有返回值的线程,5,main]---17
Thread[有返回值的线程,5,main]---18
Thread[有返回值的线程,5,main]---19
Thread[有返回值的线程,5,main]---20
Thread[有返回值的线程,5,main]---21
Thread[有返回值的线程,5,main]---22
Thread[有返回值的线程,5,main]---23
Thread[有返回值的线程,5,main]---24
Thread[有返回值的线程,5,main]---25
Thread[有返回值的线程,5,main]---26
Thread[有返回值的线程,5,main]---27
Thread[有返回值的线程,5,main]---28
Thread[有返回值的线程,5,main]---29
Thread[有返回值的线程,5,main]---30
Thread[有返回值的线程,5,main]---31
Thread[有返回值的线程,5,main]---32
Thread[有返回值的线程,5,main]---33
Thread[有返回值的线程,5,main]---34
Thread[有返回值的线程,5,main]---35
Thread[有返回值的线程,5,main]---36
Thread[有返回值的线程,5,main]---37
Thread[有返回值的线程,5,main]---38
Thread[有返回值的线程,5,main]---39
Thread[有返回值的线程,5,main]---40
Thread[有返回值的线程,5,main]---41
Thread[有返回值的线程,5,main]---42
Thread[有返回值的线程,5,main]---43
Thread[有返回值的线程,5,main]---44
Thread[有返回值的线程,5,main]---45
Thread[有返回值的线程,5,main]---46
Thread[有返回值的线程,5,main]---47
Thread[有返回值的线程,5,main]---48
Thread[有返回值的线程,5,main]---49
子线程的返回值：50

多线程以上创建方式区别

使用继承Thread类的方式创建多线程

优势： 编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

劣势： 线程类已经继承了Thread类，所以不能再继承其他父类。

采用实现Runnable、Callable接口的方式创建多线程

优势： 避免了单继承局限性；多个线程可以共享同一个接口子类的对象，非常适合多个相同线程来处理同一份资源。

劣势： 编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。

Java 多线程基本概念相关推荐

java多线程基础概念
大纲:java多线程知识体系` 程序`:为了完成某一功能, (用某种语言编写的一组指令的集合),是一段静态的代码块进程:程序的一次执行过程,是正在运行的程序,有着完整的生命周期,是资源分配的基本单位 ...
Java多线程基本概念
多线程进程.线程是动词,相当于动词(执行). 程序:静态代码,是应用程序执行的蓝本. 进程:程序的一次动态执行.(代码加载.执行.执行完毕)=> 进程:产生.发展.消亡操作系统:同时管理计算 ...
java线程内存模型_深度解析Java多线程的内存模型
内部java内存模型硬件层面的内存模型 Java内存模型和硬件内存模型的联系共享对象的可见性资源竞速 Java内存模型很好的说明了JVM是如何在内存里工作的,JVM可以理解为java执行的一个操 ...
java多线程异步调用别的系统接口代码_60 多个实例讲解，彻底搞懂 Java 多线程！
JAVA 最难学的部分是哪里?很多朋友都会说:「 java 多线程」. 随着业务量和数据的增加,企业不可避免地会使用多线程的方式处理数据.在 Java 职位的面试中,多线程也是必考的高阶知识点之一 ...
Java多线程--深入浅出Java多线程
#深入浅出Java多线程慕课网对应课程 – 深入浅出Java多线程 Java多线程基础概念进程程序(任务)的执行过程动态性持有资源(共享内存,共享文件)和线程线程线程是系统中最小的执行单 ...
【26天高效学习Java编程】Day19：60 多个实例讲解，彻底搞懂Java 多线程【可查阅，可复习，可面试】
本专栏将从基础开始,循序渐进,由浅入深讲解Java的基本使用,希望大家都能够从中有所收获,也请大家多多支持. 专栏地址:26天高效学习Java编程相关软件地址:软件地址所有代码地址:代码地址如果 ...
java多线程编程01---------基本概念
一. java多线程编程基本概念--------基本概念 java多线程可以说是java基础中相对较难的部分,尤其是对于小白,次一系列文章的将会对多线程编程及其原理进行介绍,希望对正在多线程中碰壁的小 ...
Java多线程笔记（零）：进程、线程与通用概念
前言不积跬步,无以至千里:不积小流,无以成江海.在学习Java多线程相关的知识前,我们首先需要去了解一点操作系统的进程.线程以及相关的基础概念. 进程通常,我们把一个程序的执行称为一个进程.反过来 ...
Java 多线程（一）基础知识与概念
多线程Multi-Thread 基础线程概念线程就是程序中单独顺序的流控制. 线程本身不能运行,它只能用于程序中. 说明:线程是程序内的顺序控制流,只能使用分配给程序的资源和环境. 进程进程:执 ...

Java 多线程基本概念

多线程基本概念