2022.8.20 线程简介与三种创建方式
作者：互联网
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()
-
推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用
标签：20,String,Thread,start,线程,2022.8,new,public 来源： https://www.cnblogs.com/shanzha/p/16609097.html