目录
一、线程简介
1. 任务
现实中太多这样同时做多件事情的例子了，看起来是多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事情。
2. 多线程
原来是一条路，慢慢因为车太多了，道路阻塞，效率极低。为了提高使用的效率，能够充分利用道路，于是加了多个车道。
普通方法调用和多线程调用
3. 程序>进程>线程
4.Process与Thread
- 说起进程,就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
- 而进程则是执行程序的依次执行过程，它是一个动态的概念。是系统资源分配的单位。
- 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。
5. 核心概念
- 线程就是独立的执行路径
- 在程序运行时,即使没有自己创建线程,后台也会有多个线程,比如主线程,GC线程
- main()称之为主线程,为系统的入口,用于执行整个程序
- 在一个进程中,如果开辟了多个线程,线程的运行是由调度器（cpu）安排调度的,调度器是与操作系统紧密相关的,先后顺序是不能人为干预的
- 对同一份资源操作时mm会存在资源抢夺的问题,需要加入并发控制
- 线程会带来额外的开销,如CPU调度时间,并发控制开销
- 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致
二、线程的实现
1、继承Thread类
自定义线程类继承 Thread 类
重写 run() 方法，编写线程执行体
创建线程对象，调用 start() 方法启动线程
package com.qgc.demo01;
/**
创建线程方式一：继承Thread类，重写run()方法，调用start
注意：线程开启不一定执行，由CPU调度执行
*/
public class TestThread1 extends Thread{
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程！"+i);
}
}
//main线程，主线程
public static void main(String[] args) {
//创建一个线程对象
TestThread1 thread1 = new TestThread1();
//调用start()方法开启线程
thread1.start();
for (int i = 0; i < 1000; i++) {
System.out.println("我边烤火边学习！！！！"+i);
}
}
}控制台输出：
案例：多线程同步下载图片
package com.qgc.demo01;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习Thread，实现多线程同步下载图片
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 t1 = new TestThread2("https://img-home.csdnimg.cn/images/20201124032511.png","美女1.jpg");
TestThread2 t2 = new TestThread2("https://img-home.csdnimg.cn/images/20201124032511.png","美女2.jpg");
TestThread2 t3 = new TestThread2("https://img-home.csdnimg.cn/images/20201124032511.png","美女3.jpg");
t1.start();
t2.start();
t3.start();
}
}
//下载器
class WebDownloader{
//下载方法
public void downloader(String url,String name){
try {
FileUtils.copyURLToFile(new URL(url),new File(name));
} catch (IOException e) {
e.printStackTrace();
System.out.println("IO异常，downloader方法出现错误！");
}
}
}
2、实现Runnabl接口
推荐使用Runnable对象,因为Java单继承的局限性
自定义线程类实现 Runnable 接口
实现 run()方法,编写线程执行体
创建线程对象,调用 start()方法启动对象
package com.qgc.demo01;
/**
创建线程方式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);
}
}
//main线程，主线程
public static void main(String[] args) {
//创建Runnable接口的实现类对象
TestThread3 thread3 = new TestThread3();
//创建线程对象，通过线程对象调用start()方法开启线程
new Thread(thread3).start();
for (int i = 0; i < 1000; i++) {
System.out.println("我睡觉时听歌！！！！"+i);
}
}
}
案例：买火车票
package com.qgc.demo01;
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) {
TestThread4 ticket = new TestThread4();
new Thread(ticket, "小红").start();
new Thread(ticket, "老师").start();
new Thread(ticket, "黄牛1").start();
new Thread(ticket, "黄牛2").start();
}
}
案例：龟兔赛跑
package com.qgc.demo01;
/**
* 模拟龟兔赛跑
*/
public class TestThread5 implements Runnable {
//胜利者
private static String winner;
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
//模拟兔子休息
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) {
TestThread5 race = new TestThread5();
new Thread(race, "兔子").start();
new Thread(race, "乌龟").start();
}
}
3、实现Callable接口
实现Callable接口，需要返回值类型
重写call方法，需要抛出异常
创建目标对象
创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行：Future result1 = ser.submit(11);
获取结果：boolean r1 = result1.get()
关闭服务：ser.shutdownNow();
package com.qgc.demo01;
import java.util.concurrent.*;
public class TestThread6 implements Callable<Boolean> {
private String url;//网络图片地址
private String name;//报错扥文件名
//有参构造
public TestThread6(String url, String name) {
this.url = url;
this.name = name;
}
//下载图片线程的执行体
public Boolean call() throws Exception {
WebDownloader webDownloader = new WebDownloader();
webDownloader.downloader(url, name);
System.out.println("下载了文件名为:" + name);
return true;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
TestThread6 t1 = new TestThread6("https://img-home.csdnimg.cn/images/20201124032511.png", "1.png");
TestThread6 t2 = new TestThread6("https://img-home.csdnimg.cn/images/20201124032511.png", "2.png");
TestThread6 t3 = new TestThread6("https://img-home.csdnimg.cn/images/20201124032511.png", "3.png");
//创建执行服务
ExecutorService ser = Executors.newFixedThreadPool(3);
//提交执行
Future<Boolean> r = ser.submit(t1);
Future<Boolean> r1 = ser.submit(t2);
Future<Boolean> r2 = ser.submit(t3);
//获取结果
boolean res = r.get();
boolean res1 = r1.get();
boolean res2 = r2.get();
//关闭服务
ser.shutdownNow();
}
}
实现Callable接口的好处：
- 可以定义返回值
- 可以抛出异常
4、Thread和Runnable对比
继承Thred类:
- 子类继承Thread类具备多线程能力
- 启动线程:子类对象.start()
- 不建议使用:避免OOP单继承局限性
实现Runnable接口：
- 实现接口Runnable具有多线程能力
- 启动线程:传入目标对象+Thread对象.start()
- 推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用
