1.什么是进程?
进程:在操作系统中运行的某个软件/某个程序
任何软件/程序要运行都要被加载到内存中,而内存负责运行这个软件/程序所需要的那些内存空间,就被称为当前软件在内存中的一个进程。
进程需要依赖于操作系统
进程就是在操作系统中动态运行的静态代码。
2.什么是线程?
线程就是在操作系统中动态运行的静态代码【进程】中的某一项具体功能的执行过程【执行轨迹/执行线索】。
例如:我们在window操作系统上打开“暴风影音”播放电影,此时“暴风影音”就会在window操作系统中产生一个进程;打开“暴风影音”播放电影的时候有画面,声音,中文字幕等等,这些画面,声音,中文字幕就是这个“暴风影音”进程中的多个线程。
3.什么是多线程?
多线程:某一个程序在运行的时候可能会产生多个不同的执行线索【执行轨迹】,这些多个不同的执行线索【执行轨迹】共同运行的情况就是多线程。
往往我们会感觉到这些多个不同的执行线索【执行轨迹】同时执行,实际上这时一种错觉假象,实际上当这些多个不同的执行线索【执行轨迹】在运行的时候,某一个时刻只有一个执行线索【执行轨迹】在运行,只是这多个不同的执行线索【执行轨迹】快速的切换而已。
4.为什么使用多线程?
1.使用多线程的目的就是为了提高程序的执行效率。
2.解决并发问题。
并行和并发有什么区别?
并行:多个处理器或多核处理器同时处理多个任务。
并发:多个任务在同一个 CPU 核上,按细分的时间片轮流(交替)执行,从逻辑上来看那些任务是同时执行。
5.多线程的创建方式以及区别?
第一种,通过继承Thread类创建线程类
创建步骤:
1.创建一个类,继承Thread类
2.重写run方法
3.将需要由线程执行的具体动作写入run方法
package com.wangxing.test1;
public class MyThreadClass extends Thread{
@Override
public void run() {
for(int i=1;i<=100;i++){
//得到当前正在运行的线程名称
//1.得到当前正在运行的线程对象
Thread dangqianObj=Thread.currentThread();
//2.得到线程名称
String name=dangqianObj.getName();
System.out.println(name+"---i=="+i);
}
}
}
运行步骤:
1.创建线程类的对象
2.通过线程对象调用start方法启动线程
package com.wangxing.test1;
public class TestMain {
public static void main(String[] args) {
//启动运行线程
//创建线程对象
MyThreadClass mtc1=new MyThreadClass();
MyThreadClass mtc2=new MyThreadClass();
//启动线程
mtc1.start();
mtc2.start();
}
}
第二种,通过实现Runnable接口创建线程类
Runnable接口--Thread类就实现过这个接口,只有一个run方法。
创建步骤:
1.创建一个类,实现Runnable接口
2.重写run方法
3.将需要由线程执行的具体动作写入run方法
package com.wangxing.test2;
public class MyTestThreadClass implements Runnable{
@Override
public void run() {
for(int i=1;i<=100;i++){
//得到当前正在运行的线程名称
//1.得到当前正在运行的线程对象
Thread dangqianObj=Thread.currentThread();
//2.得到线程名称
String name=dangqianObj.getName();
System.out.println(name+"---i=="+i);
}
}
}
运行步骤:
1.创建目标对象
2.通过Thread类的构造方法创建线程对象
3.通过线程对象调用start方法启动线程
package com.wangxing.test2;
public class TestMain {
public static void main(String[] args) {
//创建目标对象
MyTestThreadClass mttc=new MyTestThreadClass();
//通过Thread类的构造方法
//public Thread(Runnable target)
//将目标对象转换成线程对象
Thread th1=new Thread(mttc);
Thread th2=new Thread(mttc);
//启动线程调用start方法---Thread类
th1.start();
th2.start();
}
}
第三种,通过Callable和Future接口创建线程
java.util.concurrent.Callable接口--这个接口中只有一个方法call()
java.util.concurrent.Future接口--有一个重要方法get()
1. public boolean cancel(boolean mayInterruptIfRunning)
是否取消正在执行的线程任务[false为取消任务]
2. public boolean isCancelled()判断是否是线程任务没有运行结束之前取消线程
3. public boolean isDone()判断线程任务是否正常执行完毕
4. V get()得到线程任务的执行结果
java.util.concurrent.FutureTask类--继承了Runnable接口
1. public boolean cancel(boolean mayInterruptIfRunning)是否取消正在执行的线程任务
2. public boolean isCancelled()判断是否是线程任务没有运行结束之前取消线程
3. public boolean isDone()判断线程任务是否正常执行完毕
4. V get()得到线程任务的执行结果
创建步骤:
1.创建一个类,实现Callable接口
2.重写call();
3.将需要由线程执行的具体动作写入call()方法
注意:实现Callable接口的时候需要指定线程执行结果的返回值类型
运行步骤:
1.创建目标对象
2.通过FutureTask类的构造方法public FutureTask(Callable<V> callable)封装目标对象成Runnable子类对象
3.通过Thread类的构造方法public Thread(Runnable runnable)创建线程对象
例如:没有接收线程返回值的操作
package com.wangxing.test3;
import java.util.concurrent.Callable;
public class MyThread implements Callable{
@Override
public Object call() throws Exception {
for(int i=1;i<=100;i++){
//得到当前正在运行的线程名称
//1.得到当前正在运行的线程对象
Thread dangqianObj=Thread.currentThread();
//2.得到线程名称
String name=dangqianObj.getName();
System.out.println(name+"---i=="+i);
}
return null;
}
}
package com.wangxing.test3;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RunnableFuture;
public class TestMain {
public static void main(String[] args) {
//启动线程---strat方法---Thread类---MyThread类与Thread类联系起来
//创建目标对象
MyThread mt=new MyThread();
//通过Future接口的子类FutureTask的构造方法
//public FutureTask(Callable<V> callable)
//将目标对象转换成Future接口的子类FutureTask对象
//FutureTask类实现类RunnableFuture<V>接口
//RunnableFuture<V>接口又继承了Runnable接口
FutureTask futruetask1=new FutureTask(mt);
FutureTask futruetask2=new FutureTask(mt);
//通过Thread类的构造方法
//public Thread(Runnable target)
//将Runnable接口转换成课Thread类对象
Thread th1=new Thread(futruetask1);
Thread th2=new Thread(futruetask2);
th1.start();
th2.start();
}
}
例如:接收线程返回值的操作
package com.wangxing.test4;
import java.util.concurrent.Callable;
public class MyThreadClass implements Callable<Integer>{
@Override
public Integer call() throws Exception {
int i=1;
int sum=0;
while(i<=100){
//得到当前正在运行的线程名称
//1.得到当前正在运行的线程对象
Thread dangqianObj=Thread.currentThread();
//2.得到线程名称
String name=dangqianObj.getName();
System.out.println(name+"---i=="+i);
sum=sum+i;
i++;
}
return sum;
}
}
package com.wangxing.test4;
import java.util.concurrent.FutureTask;
public class TestMain {
public static void main(String[] args)throws Exception {
//创建目标对象
MyThreadClass mtc=new MyThreadClass();
//创建FutureTask对象
FutureTask futureTask1=new FutureTask(mtc);
FutureTask futureTask2=new FutureTask(mtc);
//创建线程对象
Thread th1=new Thread(futureTask1);
Thread th2=new Thread(futureTask2);
//启动线程
th1.start();
th2.start();
//得到线程的运行结果
//Future接口的get方法
//FutureTask类是Future接口的字节,get方法被FutureTask类继承
//FutureTask类的get方法得到线程的执行结果
Object obj1=futureTask1.get();
int thres1=(Integer)obj1;
System.out.println("线程1的运行结果=="+thres1);
Object obj2=futureTask2.get();
int thres2=(Integer)obj2;
System.out.println("线程2的运行结果=="+thres2);
}
}
第四种,通过线程池创建多线程【使用的比较少,所以不强调】
多线程的创建方式的区别
继承Thread类
1.创建新类继承Thread类重写run方法
2.run方法没有返回值,不能声明抛出异常
3.创建Thread类的子类对象【线程对象】,通过子类对象调用start方法启动线程
4.无法资源共享
5.不考虑资源共享时
实现Runnable接口
1.创建新类实现Runnable接口重写run方法
2.run方法没有返回值,不能声明抛出异常
3.创建实现Runnable接口的子类对象【目标对象】,通过Thread的构造方法将目标对象转换成线程对象,通过线程对象调用start方法启动线程
4.可以资源共享
5.考虑资源共享时
Callable和Future接口
1.创建新类实现Callable接口重写call方法,注意Callable接口的泛型类型[返回值类型]
2.call方法有返回值,通过Future接口提供的get方法得到返回值,可以声明抛出异常
3.创建实现Callable接口的子类对象【目标对象】,通过Future接口的子类FutureTask将Callable接口的子类转换成Runnable接口类型,通过Thread的构造方法将Runnable接口类型对象转换成线程对象,通过线程对象调用start方法启动线程。
4.可以资源共享
5.考虑资源共享时,异步编程