1、线程简介
1.多任务
现实中太多这样同时做多件事情的例子了,看起来是多个任务都在做,其实本质上我们的大脑在同一时间依旧只做了一件事情。
2.多线程
原来是一条路,慢慢因为车太多了,道路阻塞,效率极低。为了提高使用的效率,能够充分利用道路,于是加了多个车道。从此,妈妈再也不用担心道路阻塞了。
3.程序.进程.线程
4.Process与Thread
-
说起进程,就不得不说下程序。程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。
-
而进程则是执行程序的依次执行过程,它是一个动态的概念。是系统资源分配的单位。
-
通常在一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义。线程是CPU调度和执行的单位。
注意: 很多多线程是模拟出来的,真正的多线程是指有多个cpu,即多核,如服务器。如果是模拟出来的多线程,即在一个cpu的情况下,在同一个时间点,cpu只能执行一个代码,因为切换的很快,所以就有同时执行的错局。
5.核心概念
-
线程就是独立的执行路径
-
在程序运行时,即使没有自己创建线程,后台也会有多个线程,比如主线程,gc线程
-
main()称之为主线程,为系统的入口,用于执行整个程序
-
在一个进程中,如果开辟了多个线程,线程的运行是由调度器(cpu)安排调度的,调度器是与操作系统紧密相关的,先后顺序是不能人为干预的
-
对同一份资源操作时mm会存在资源抢夺的问题,需要加入并发控制
-
线程会带来额外的开销,如CPU调度时间,并发控制开销
-
每个线程在自己的工作内存交互,内存控制不当会造成数据不一致
2、线程创建(三种方法)
2.1、继承Thread类(重要)
自定义线程类继承Thread
类
重写run()
方法,编写线程执行体
创建线程对象,调用start()
方法启动线程
package com.xing.demo01;
/**
* @program: 多线程
* @Date: 2022/08/14
* @author: 16159
* @description:
* @Modified By:
**/
public class TestThread extends Thread {
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码----" + i);
}
}
public static void main(String[] args) {
//main线程,主线程
//创建一个线程对象
TestThread testThread = new TestThread();
//调用start()开启线程,
// 如果这里是testThread.run();那么先执行run方法,在执行下面的代码
// 如果这里是testThread.start();线程不一定立即执行,CPU安排调度
testThread.start();
for (int i = 0; i < 2000; i++) {
System.out.println("我在学习多线程----" + i);
}
}
}
总结:线程不一定立即执行,CPU安排调度
案例
下载commons-io-2.11.0.jar包
创建lib目录,将包复制进去
导包成功
package com.xing.demo01;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
/**
* @program: 多线程
* @Date: 2022/08/14
* @author: 16159
* @description:
* @Modified By:
**/
public class TestThread2 extends Thread {
private String url;//网络图片地址
private String name;//保存的文件名
//有参构造
public TestThread2(String url, String name) {
this.url = url;
this.name = name;
}
//下载图片线程的执行体
@Override
public void run() {
WebDownloader webDownloader = new WebDownloader();
webDownloader.downloader(url, name);
System.out.println("下载了文件名为:" + name);
}
public static void main(String[] args) {
TestThread2 t = new TestThread2("https://img-home.csdnimg.cn/images/20201124032511.png", "1.png");
TestThread2 t1 = new TestThread2("https://img-home.csdnimg.cn/images/20201124032511.png", "2.png");
TestThread2 t2 = new TestThread2("https://img-home.csdnimg.cn/images/20201124032511.png", "3.png");
t.start();
t1.start();
t2.start();
}
}
//下载器
class WebDownloader {
//下载方法
public void downloader(String url, String name) {
try {
// 将一个url变成一个文件
FileUtils.copyURLToFile(new URL(url), new File(name));
} catch (IOException e) {
e.printStackTrace();
System.out.println("IO异常,downloader方法出现问题");
}
}
}
线程"同时"执行,不是按照顺序
2.2、实现Runnable接口
推荐使用Runnable对象,因为Java单继承的局限性
自定义线程类实现Runnable
接口
实现run()
方法,编写线程执行体
创建线程对象,调用start()
方法启动对象
相较于方法1,多了一个代理
package com.xing.demo01;
/**
* @program: 多线程
* @Date: 2022/08/14
* @author: 16159
* @description:
* @Modified By:
**/
//创建线程方式2﹔实现runnable接口,重写run方法,执行线程需要丢入runnable接口实现类.调用start方法.
//这就是一个线程
public class TestThread3 implements Runnable {
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码----" + i);
}
}
public static void main(String[] args) {
//创建runnable接口的实现类
TestThread3 testThread = new TestThread3();
Thread thread = new Thread(testThread);
//调用start()开启线程
thread.start();
//new Thread(testThread).start();
for (int i = 0; i < 2000; i++) {
System.out.println("我在学习多线程----" + i);
}
}
}
案例
火车票:
package com.xing.demo01;
/**
* @program: 多线程
* @Date: 2022/08/14
* @author: 16159
* @description:多个线程同时操作同一个对象 买火车票案例
* @Modified By:
**/
//发现问题:多个线程操作同一个资源的情况下,线程不安全,数据紊乱
public class TestThread4 implements Runnable {
//票数
private int ticketNums = 10;
@Override
public void run() {
while (true) {
if (ticketNums <= 0) {
break;
}
//模拟延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 当前执行线程的名字
System.out.println(Thread.currentThread().getName() + "--->拿到了第" + ticketNums-- + "张票");
}
}
public static void main(String[] args) {
//创建runnable接口的实现类
TestThread4 ticket = new TestThread4();
//创建线程对象,通过线程对象来开启我们的线程,代理
new Thread(ticket, "小红").start();
new Thread(ticket, "老师").start();
new Thread(ticket, "黄牛1").start();
new Thread(ticket, "黄牛2").start();
}
}
有问题:多个线程操作同一个资源的情况下,线程不安全,数据紊乱
龟兔赛跑:
package com.xing.demo01;
/**
* 模拟龟兔赛跑
*/
public class Race implements Runnable {
//胜利者
private static String winner;
@Override
public void run() {
//长度100m
for (int i = 0; i <= 100; i++) {
//模拟兔子休息 每10步兔子休息
if (Thread.currentThread().getName().equals("兔子") && i % 10 == 0) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//判断比赛是否结束
boolean flag = gameOver(i);
//如果比赛结束,停止程序
if (flag) {
break;
}
System.out.println(Thread.currentThread().getName() + "--->跑了" + i + "步");
}
}
//判断是否完成比赛
private boolean gameOver(int steps) {
if (winner != null) {
return true;
} else {
if (steps >= 100) {
winner = Thread.currentThread().getName();
System.out.println("winner is " + winner);
return true;
}
}
return false;
}
public static void main(String[] args) {
Race race = new Race();
new Thread(race, "兔子").start();
new Thread(race, "乌龟").start();
}
}
2.3、实现Callable接口(了解)
实现Callable接口,需要返回值类型
重写call方法,需要抛出异常
创建目标对象
创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行:Future result1 = ser.submit(11);
获取结果:boolean r1 = result1.get()
关闭服务:ser.shutdownNow();
实现
package com.xing.demo02;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;
/**
* 实现Callable接口 有返回值
*/
public class TestCallable implements Callable<Boolean> {
private String url;//网络图片地址
private String name;//报错扥文件名
//有参构造
public TestCallable(String url, String name) {
this.url = url;
this.name = name;
}
//下载图片线程的执行体
public Boolean call(){
WebDownloader webDownloader = new WebDownloader();
webDownloader.downloader(url, name);
System.out.println("下载了文件名为:" + name);
return true;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
TestCallable c = new TestCallable("https://img-home.csdnimg.cn/images/20201124032511.png", "1.png");
TestCallable c1 = new TestCallable("https://img-home.csdnimg.cn/images/20201124032511.png", "2.png");
TestCallable c2 = new TestCallable("https://img-home.csdnimg.cn/images/20201124032511.png", "3.png");
//创建执行服务
ExecutorService ser = Executors.newFixedThreadPool(3);
//提交执行
Future<Boolean> r = ser.submit(c);
Future<Boolean> r1 = ser.submit(c1);
Future<Boolean> r2 = ser.submit(c2);
//获取结果
boolean res = r.get();
boolean res1 = r1.get();
boolean res2 = r2.get();
//关闭服务
ser.shutdownNow();
}
}
//下载器
class WebDownloader {
//下载方法
public void downloader(String url, String name) {
try {
// 将一个url变成一个文件
FileUtils.copyURLToFile(new URL(url), new File(name));
} catch (IOException e) {
e.printStackTrace();
System.out.println("IO异常,downloader方法出现问题");
}
}
}
package com.xing.demo03;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @ClassName ThreadFutureTest
* @Description TODO
* @Author sjmp1573
* @Date DATE{TIME}
*/
public class ThreadFutureTest {
public static class MyThread implements Callable<String>{
@Override
public String call() throws Exception {
return "Thread-Callable- hello";
}
}
public static void main(String[] args) {
FutureTask<String> futureTask = new FutureTask<>(new MyThread());
new Thread(futureTask).start();
try {
//获取返回值
String result = futureTask.get();
System.out.println(result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
如上代码中的 MyThread类实现了 Callable 接口的 call() 方法。在 main 函数内首先创建了一个 FutrueTask 对象(构造函数为 MyThread的实例),然后使用创建的 FutrueTask 对象作为任务创建了一个线程并且启动它,最后通过futureTask.get() 等待任务执行完毕并返回结果。
小结:使用继承方式的好处是方便传参,你可以在子类里面添加成员变量,通过 set 方法设置参数或者通过构造函数进行传递,而如果使用 Runnable 方式,则只能使用主线程里面被声明为 final 的变量。不好的地方是 Java 不支持多继承,如果继承了 Thread 类,那么子类不能再继承其他类,而 Runable 则没有这个限制。前两种方式都没办法拿到任务的返回结果,但是 Futuretask 方式可以。
好处
可以定义返回值
可以抛出异常
2.4、Thread和Runnable对比
继承Thred类:
-
子类继承Thread类具备多线程能力
-
启动线程:子类对象.start()
-
不建议使用:避免OOP单继承局限性
实现Runnable接口
-
实现接口Runnable具有多线程能力
-
启动线程:传入目标对象+Thread对象.start()
-
推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用