多线程1
10.1.什么是多线程?
- 什么是进程?
进程:在操作系统中运行的某个软件/某个程序(主要是指在内存中)。[动态]
任何软件/程序要运行都要被加载到内存中,而内存负责运行这个软件/程序所需要的那些内存空间,就被称为当前软件在内存中的一个进程。
- 进程需要依赖于操作系统
进程就是在操作系统中动态运行的静态代码。 - 什么是线程?
线程就是在操作系统中动态运行的静态代码【进程】中的某一项具体功能的执行过程【执行轨迹/执行线索】。
例如:
我们在window操作系统上打开“暴风影音”播放电影,此时“暴风影音”就会在window操作系统中产生一个进程;打开“暴风影音”播放电影的时候有画面,声音,中文字幕等等,这些画面,声音,中文字幕就是这个“暴风影音”进程中的多个线程。
进程 | 线程 |
---|---|
依赖操作系统 | 依赖进程 |
进程与进程之间的交互很困难 | 线程与线程之间的交互很容易 |
3. 什么是多线程?
多线程:某一个程序在运行的时候可能会产生多个不同的执行线索【执行轨迹】,这些多个不同的执行线索【执行轨迹】共同运行的情况就是多线程。
往往我们会感觉到这些多个不同的执行线索【执行轨迹】同时执行,实际上这时一种错觉假象,实际上当这些多个不同的执行线索【执行轨迹】在运行的时候,某一个时刻只有一个执行线索【执行轨迹】在运行,只是这多个不同的执行线索【执行轨迹】快速的切换而已。
4.为什么使用多线程?
1.使用多线程的目的就是为了提高程序的执行效率。
2.解决并发问题。
并行和并发有什么区别?
并行:多个处理器或多核处理器同时处理多个任务。
并发:多个任务在同一个 CPU 核上,按细分的时间片轮流(交替)执行,从逻辑上来看那些任务是同时执行。
如下图:【并发 = 两个队列和一台咖啡机】 【并行 = 两个队列和两台咖啡机】
10.2.多线程的创建方式以及区别
Java中的线程
当一个java程序启动运行以后,至少有2个线程在运行。
- 主线程,就是java程序的主方法执行线索
- 垃圾回收线程。
Java中多线程的创建方式【4种】
第一种,通过继承Thread类创建线程类
- 创建一个类,继承Thread类
- 重写run方法
- 将需要由线程执行的具体动作写入run方法
package com.wangxing.test1;
/**
* 1.创建一个类,继承Thread类
* 2.重写run方法
* 3.将需要由线程执行的具体动作写入run方法
* @author Administrator
*
*/
public class TestThread extends Thread{
//通过继承Thread类创建线程类
@Override
public void run() {
//得到当前线程的名称
String name=Thread.currentThread().getName();
for(int i=0;i<=100;i++){
System.out.println(name+"----i=="+i);
}
}
}
测试类:
package com.wangxing.test1;
public class testmain {
public static void main(String[] args) {
//启动线程
//1.创建线程对象
//2.通过线程对象调用start方法启动线程
TestThread tth1=new TestThread();
tth1.start();
TestThread tth2=new TestThread();
tth2.start();
}
}
第二种,通过实现Runnable接口创建线程类
- 创建一个类,实现Runnable接口
- 重写run方法
- 将需要由线程执行的具体动作写入run方法
package com.wangxing.test2;
/**
* 通过实现Runnable接口创建线程类
* 1. 创建一个类,实现Runnable接口
* 2. 重写run方法
* 3. 将需要由线程执行的具体动作写入run方法
* @author Administrator
*
*/
public class MyThread implements Runnable {
@Override
public void run() {
//得到当前线程的名称
String name=Thread.currentThread().getName();
for(int i=0;i<=100;i++){
System.out.println(name+"----i=="+i);
}
}
}
测试类:
package com.wangxing.test2;
public class TestMain {
public static void main(String[] args) {
/*
* 1.创建有线程类执行的目标对象【实现Runnable接口的java类对象】
* 2.创建线程对象【java.lang.Thread类的对象】
* public Thread(Runnable target)
* public Thread(Runnable target, String name)
* 3.调用start方法启动线程运行
*/
MyThread mt=new MyThread();
Thread th1=new Thread(mt);
th1.start();
Thread th2=new Thread(mt);
th2.start();
}
}
第三种,通过Callable和Future接口创建线程
通过这两个接口创建线程,你要知道这两个接口的作用,下面我们就来了解这两个接口:
通过实现Runnable接口创建多线程时,Thread类的作用就是把run()方法包装成线程的执行体,那么,是否可以直接把任意方法都包装成线程的执行体呢?
从JAVA5开始,JAVA提供提供了Callable接口,该接口是Runnable接口的增强版,Callable接口提供了一个call()方法可以作为线程执行体,但call()方法比run()方法功能更强大,call()方法的功能的强大体现在:
1、call()方法可以有返回值;
2、call()方法可以声明抛出异常;
从这里可以看出,完全可以提供一个Callable对象作为Thread的target,而该线程的线程执行体就是call()方法。
问题是:Callable接口是JAVA新增的接口,而且它不是Runnable接口的子接口,所以Callable对象不能直接作为Thread的target。还有一个原因就是:call()方法有返回值,call()方法不是直接调用,而是作为线程执行体被调用的,所以这里涉及获取call()方法返回值的问题。
于是,JAVA5提供了Future接口来代表Callable接口里call()方法的返回值,并为Future接口提供了一个FutureTask实现类,该类实现了Future接口,并实现了Runnable接口,所以FutureTask可以作为Thread类的target,同时也解决了Callable对象不能作为Thread类的target这一问题。
在Future接口里定义了如下几个公共方法来控制与它关联的Callable任务:
1、boolean cancel(boolean mayInterruptIfRunning):试图取消Future里关联的Callable任务;
2、V get():返回Callable任务里call()方法的返回值,调用该方法将导致程序阻塞,必须等到子线程结束以后才会得到返回值;
3、V get(long timeout, TimeUnit unit):返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间,如果经过指定时间后,Callable任务依然没有返回值,将会抛出TimeoutException异常;
4、boolean isCancelled():如果Callable任务正常完成前被取消,则返回true;
5、boolean isDone():如果Callable任务已经完成, 则返回true;
这种方式创建并启动多线程的步骤如下:
1、创建Callable接口实现类,并实现call()方法,该方法将作为线程执行体,且该方法有返回值,再创建Callable实现类的实例;
2、使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值;
3、使用FutureTask对象作为Thread对象的target创建并启动新线程;
4、调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。
package com.wangxing.test3;
import java.util.concurrent.Callable;
/**
* 第三种方法:
* 创建Callable接口实现类,并实现call()方法,该方法将作为线程执行体,
* 且该方法有返回值,再创建Callable实现类的实例;
* 2、使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值;
* 3、使用FutureTask对象作为Thread对象的target创建并启动新线程;
* 4、调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。
* @author Administrator
*
*/
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
//得到当前线程的名称
String name=Thread.currentThread().getName();
for(int i=1;i<=100;i++) {
System.out.println(name+"--i=="+i);
}
return name+"执行完毕";
}
}
测试类:
package com.wangxing.test3;
import java.util.concurrent.FutureTask;
public class TestMain {
/*
* 1、boolean cancel(boolean mayInterruptIfRunning):试图取消Future里关联的Callable任务;
* 2、V get():返回Callable任务里call()方法的返回值,调用该方法将导致程序阻塞,必须等到子线程结束以后才会得到返回值;
* 3、V get(long timeout, TimeUnit unit):返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间,如果经过指定时间后,Callable任务依然没有返回值,将会抛出TimeoutException异常;
* 4、boolean isCancelled():如果Callable任务正常完成前被取消,则返回true;
* 5、boolean isDone():如果Callable任务已经完成, 则返回true;
*/
public static void main(String[] args)throws Exception {
//目标对象
MyCallable mc=new MyCallable();
//将目标对象包装成Runnable的子类
/*
FutureTask是RunnableFuture子类,
RunnableFuture是Runnable的子类
*/
FutureTask<Integer> task1=new FutureTask(mc);
FutureTask<Integer> task2=new FutureTask(mc);
//线程对象
Thread Th1=new Thread(task1);
Thread Th2=new Thread(task2);
//调用start方法启动线程
Th1.start();
Th2.start();
//测试方法
//5、boolean isDone():如果Callable任务已经完成, 则返回true;
//2、V get():返回Callable任务里call()方法的返回值,调用该方法将导致程序阻塞,必须等到子线程结束以后才会得到返回值;
Object returntask1=task1.get();
System.out.println(returntask1);
Object returntask2=task2.get();
System.out.println(returntask2);
}
}
第四种,通过线程池创建多线程【使用的比较少,所以不强调】
区别:
继承Thread类 | 实现Runnable接口 | Callable和Future接口 |
创建新类继承Thread类重写run方法 | 创建新类实现Runnable接口重写run方法 | 创建新类实现Callable接口重写call方法,注意Callable接口的泛型类型 |
run方法没有返回值,不能声明抛出异常 | call方法有返回值,通过Future接口提供的get方法得到返回值,可以声明抛出异常 | |
创建Thread类的子类对象【线程对象】,通过子类对象调用start方法启动线程 | 创建实现实现Runnable接口的子类对象【目标对象】,通过Thread的构造方法,关联目标对象,创建线程对象【Thread类的对象】,通过线程对象调用start方法启动线程 | 创建实现Callable接口的子类对象【目标对象】,通过Future接口的子类FutureTask将目标对象包装成Runnable接口的子类对象,通过Thread的构造方法,关联FutureTask包装成的Runnable接口的子类对象,创建线程对象【Thread类的对象】,通过线程对象调用start方法启动线程 |
无法资源共享 | 可以资源共享 | 可以资源共享 |
不考虑资源共享时 | 考虑资源共享时 | 考虑资源共享时,异步编程 |
资源是否共享:
继承Thread类:
package com.wangxing.test4;
public class TestThread extends Thread{
private int piao=5;
public void run(){
boolean flag=true;
while(flag){
if(piao>0){
piao =piao-1;
System.out.println(Thread.currentThread().getName()+"卖出一张票,还剩"+piao+"张");
}
else{
flag=false;
}
}
}
}
测试类:
package com.wangxing.test4;
import java.util.concurrent.FutureTask;
public class TestMain {
public static void main(String[] args) {
//第一种多线程---资源不共享
TestThread Th1=new TestThread();
TestThread Th2=new TestThread();
Th1.start();
Th2.start();
}
}
实现Runnable接口:
package com.wangxing.test4;
public class MyThread implements Runnable{
private int piao=5;
@Override
public void run() {
boolean flag=true;
while(flag){
if(piao>0){
piao =piao-1;
System.out.println(Thread.currentThread().getName()+"卖出一张票,还剩"+piao+"张");
}
else{
flag=false;
}
}
}
}
测试类:
package com.wangxing.test4;
import java.util.concurrent.FutureTask;
public class TestMain {
public static void main(String[] args) {
//第二种多线程---资源共享
MyThread mt=new MyThread();
Thread th1=new Thread(mt);
th1.start();
Thread th2=new Thread(mt);
th2.start();
}
}
实现Callable和Future接口:
package com.wangxing.test4;
import java.util.concurrent.Callable;
public class MyCallable implements Callable{
private int piao=5;
@Override
public Object call() throws Exception {
boolean flag=true;
while(flag){
if(piao>0){
piao =piao-1;
System.out.println(Thread.currentThread().getName()+"卖出一张票,还剩"+piao+"张");
}
else{
flag=false;
}
}
return null;
}
}
测试类:
package com.wangxing.test4;
import java.util.concurrent.FutureTask;
public class TestMain {
public static void main(String[] args) {
//第三种多线程---资源共享
MyCallable mc=new MyCallable();
FutureTask fu=new FutureTask<>(mc);
Thread th1=new Thread(fu);
Thread th2=new Thread(fu);
th2.start();
th1.start();
}
}