Java多线程详解
线程简介
-
多任务
看起来多个任务都在做,本质上大脑在同一时间依旧只做了一件事
-
多线程
交通:多个车道的车辆同时运行
打游戏:多个用户同时在多个线程进行
-
线程和进程关系
- Process与Thread
- 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
- 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
- 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的的单位。 注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。
- 核心概念
- 线程就是独立的执行路径
- 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程, gc线程
- main()称之为主线程,为系统的入口,用于执行整个程序
- 在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统紧密相关的,线程的先后顺序是不能人为干预的
- 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制;
- 线程会带来额外的开销,如CPU调度时间,并发控制开销
- 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致
线程三种创建方式
- 继承Thread类
- 实现Runnable接口
- Callable接口(现阶段了解)
继承Thread类
- 自定义线程类继承Thread类
- 重写run()方法,编写线程执行体
- 创建线程对象,调用start()方法启动线程
- 不建议使用,避免OOP单继承局限性
package com.monki.javathread;
//创建线程方式1 :继承Thread类,重写run()方法,调用start开启线程
//总结: 注意,线程开启不一定立即执行,由cpu调度执行
public class ThreadTest1 extends Thread{
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码");
}
}
public static void main(String[] args) {
//main线程,主线程
//创建一个线程对象
ThreadTest1 threadTest1 = new ThreadTest1();
//调用start()方法开启线程
threadTest1.start();
threadTest1.run();//普通方法调用
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程-"+i);
}
}
}
案例:下载图片
package com.monki.javathread;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习Thread,实现多线程同步下载图片
public class ThreadTest2 extends Thread{
private String url;//网络图片地址
private String name;//保存的文件名
public ThreadTest2(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) {
ThreadTest2 t1= new ThreadTest2("https://monkifantasy.github.io/assets/html1.png","html1.jpg");
ThreadTest2 t2= new ThreadTest2("https://monkifantasy.github.io/assets/html2.png","html2.jpg");
ThreadTest2 t3= new ThreadTest2("https://monkifantasy.github.io/assets/css3.png","css3.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方法出现异常");
}
}
}
使用到的org.apache.commons.io包下载链接:(Commons IO – Commons IO Overview (apache.org)
实现Runnable接口
- 自定义线程类实现Runnable接口
- 重写run()方法,编写线程执行体
- 创建线程对象,通过线程对象来开启我们的线程,代理
- 推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用
package com.monki.javathread;
//创建线程方式2 : 实现Runnable接口,重写run()方法,执行线程需要丢入Runable接口实现类,调用start方法
public class ThreadTest3 implements Runnable{
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码");
}
}
public static void main(String[] args) {
//main线程,主线程
//创建一个Runnable接口的实现类对象
ThreadTest3 threadTest3 = new ThreadTest3();
//创建线程对象,通过线程对象来开启我们的线程,代理
new Thread(threadTest3).start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程-"+i);
}
}
}
初识并发问题
package com.monki.javathread;
//多个线程同时操作同一个对象
//买火车票的例子
//发现问题,多个线程操作同一个资源时,线程不安全,数据紊乱
public class ThreadTest4 implements Runnable{
//票数
private int ticketNums = 10;
@Override
public void run() {
while (true){
if (ticketNums<=0) break;
//模拟延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"张票");
}
}
public static void main(String[] args) {
ThreadTest4 ticket = new ThreadTest4();
new Thread(ticket,"小米").start();
new Thread(ticket,"京东").start();
new Thread(ticket,"淘宝").start();
}
}
京东-->拿到了第10张票
淘宝-->拿到了第8张票
小米-->拿到了第9张票
京东-->拿到了第7张票
小米-->拿到了第6张票
淘宝-->拿到了第6张票
京东-->拿到了第4张票
淘宝-->拿到了第4张票
小米-->拿到了第5张票
京东-->拿到了第2张票
淘宝-->拿到了第3张票
小米-->拿到了第2张票
淘宝-->拿到了第0张票
京东-->拿到了第1张票
小米-->拿到了第1张票
案例:龟兔赛跑-Race
package com.monki.javathread;
//模拟龟兔赛跑
public class Race 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(198);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
//模拟乌龟速度
if(Thread.currentThread().getName().equals("乌龟")&&i%1==0){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
//判断比赛是否结束
Boolean flag = gameOver(i);
if(flag){
break;
}
System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
}
}
//判断比赛是否结束
private boolean gameOver(int steps){
if(winner!=null){
//已经存在胜利者了
return true;
}{
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();
}
}
实现Callable接口(了解即可)
package com.monki.javathread;
import java.util.concurrent.*;
//线程创建方式3:实现callable接口
/*
Callable的好处
1.可以定义返回值
2.可以抛出异常
* */
public class CallableTest implements Callable<Boolean> {
private String url;//网络图片地址
private String name;//保存的文件名
public CallableTest(String url,String name){
this.url=url;
this.name=name;
}
//下载图片线程的执行体
@Override
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 {
CallableTest t1= new CallableTest("https://monkifantasy.github.io/assets/html1.png","html1.jpg");
CallableTest t2= new CallableTest("https://monkifantasy.github.io/assets/html2.png","html2.jpg");
CallableTest t3= new CallableTest("https://monkifantasy.github.io/assets/css3.png","css3.jpg");
//创建执行服务:
ExecutorService ser = Executors.newFixedThreadPool(3);
//提交执行:
Future<Boolean> r1 = ser.submit(t1);
Future<Boolean> r2 = ser.submit(t2);
Future<Boolean> r3 = ser.submit(t3);
//获取结果
Boolean rs1 = r1.get();
Boolean rs2 = r2.get();
Boolean rs3 = r3.get();
System.out.println(rs1);
System.out.println(rs2);
System.out.println(rs3);
//关闭服务
ser.shutdown();
}
}
静态代理
案例1:结婚
package com.monki.javathread;
//静态代理模式
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//好处:
// 代理对象可以做真实对象做不了的事情
// 真实对象专注做自己的事情
public class StaticProxy {
public static void main(String[] args) {
WeddingCompany weddingCompany = new WeddingCompany(new You());
weddingCompany.HappyMarry();
}
}
interface Marry{
//人间四大喜事
//久旱逢甘露
//他乡遇故知
//洞房花烛夜
//金榜提名时
void HappyMarry();
}
//真实角色,你去结婚
class You implements Marry{
@Override
public void HappyMarry() {
System.out.println("你要结婚了,开心吗");
}
}
//代理角色:帮助你结婚
class WeddingCompany implements Marry{
//代理谁-->真实目标角色
private Marry target;//一个接口对象,需要传入实现了该接口的类的对象
public WeddingCompany(Marry target) {
this.target = target;
}
@Override
public void HappyMarry() {
before();
this.target.HappyMarry();//这就是真实对象
after();
}
private void before() {
System.out.println("结婚之前布置");
}
private void after() {
System.out.println("结婚之后收尾款");
}
}
案例2:王者荣耀游戏工作室接单
package com.monki.javathread;
//体会静态代理:工作室打手帮老板拿标的例子
public class StaticProxy2 {
public static void main(String[] args) {
WorkStation station = new WorkStation(new User());
station.obtain();
}
}
interface GetMyIcon{
void obtain();//老板拿标后需要炫耀
}
class User implements GetMyIcon{//要拿标的用户
@Override
public void obtain() {
System.out.println("老板:跟朋友炫耀");
}
}
class WorkStation implements GetMyIcon{
private GetMyIcon target;//需要拿标的老板
public WorkStation(GetMyIcon target) {
this.target = target;
}
@Override
public void obtain() {
callPlayer();
waitForFeedback();
playerFeedback();
this.target.obtain();
}//帮助老板拿标的工作室
public void callPlayer(){
System.out.println("工作室召唤了一位打手");
}
public void waitForFeedback(){
System.out.println("打手已接单,等待反馈");
}
public void playerFeedback(){
System.out.println("打手:已达到老板要求");
}
}
多线程静态代理的思想:Thread类和用户自定义线程类都实现了Runnable接口,用户重写的run方法相当于用户想做的事,而用户想实现多线程,就把实现了Runable接口的自定义线程类丢给Thread类,Thread类就充当为一个工作室,代理用户实现多线程.
Lambda表达式
- 希腊字母表中排序11位的字母,英语名称为lambda
- 避免匿名内部类定义过多
- 去掉部分无意义代码,留下核心逻辑
- 理解Functional Interface(函数式接口是学习Java8 lambda表达式的关键所在)
- 任何接口,如果只有唯一一个抽象方法,那么他就是一个函数式接口
- 对于函数式接口我们可以通过lambda表达式创建该接口的对象
- 函数式接口是使用lambda表达式的前提
lambda表达式的推导
package com.monki.javathread;
/*
推导lambda表达式
*/
public class LambdaTest {
//3.静态内部类
static class Like2 implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda2");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lambda();
like = new Like2();
like.lambda();
//4.局部内部类
class Like3 implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda3");
}
}
like = new Like3();
like.lambda();
//5.匿名内部类,没有类的名称,必须借助接口或者父类
like = new ILike() {
@Override
public void lambda() {
System.out.println("I like lambda4");
}
};
like.lambda();
//6.用lambda简化
like =()->{
System.out.println("I like lambda5");
};
like.lambda();
}
}
//1.定义一个函数式接口
interface ILike{
void lambda();
}
//2.实现类
class Like implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda");
}
}
lambda表达式的简化
package com.monki.javathread;
public class LambdaTest2 {
public static void main(String[] args) {
ILove love = null;
//1.带参数lambda
love = (int a) ->{
System.out.println("I love you-->" + a);
};
//2.简化1.去掉了参数类型(多个参数也可以去掉参数类型,要去掉就都去掉)
love = (a)->{
System.out.println("I love you-->" + a);
};
//3.简化2.简化括号(多个参数不能去括号)
love = a ->{System.out.println("I love you-->" + a);};
//4.简化3.简化花括号(方法中只有一条语句)
love = a -> System.out.println("I love you-->" + a);
love.love(3);
}
}
interface ILove{
void love(int a);
}
与多线程联系:多线程的Runnable接口只有一个方法,是函数式接口,可以使用lambda表达式实现
线程停止
- 不推荐使用JDK提供的destroy(),stop()方法（已废弃
- 推荐线程自己停止下来
- 建议使用标志位停止线程
package com.monki.javathread;
//测试stop
//1.建议线程正常停止
//2.建议使用标志位
//3.不要使用stop等过时的方法
public class StopTest implements Runnable{
//1.设置一个标志位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while (flag){
System.out.println("running Thread"+i++);
}
}
//2.设置一个公开的方法停止线程，转换标志位
public void stop(){
this.flag=false;
}
public static void main(String[] args) {
StopTest stopTest = new StopTest();
new Thread(stopTest).start();
for (int i = 0; i < 1000; i++) {
System.out.println("线程mian"+i);
if(i==900){
stopTest.stop();
System.out.println("线程停止了");
}
}
}
}
线程休眠
- sleep（time）指定 线程阻塞的毫秒数（1000ms=1s)
- sleep存在异常InterruptedException;
- sleep时间达到后线程进入就绪状态
- sleep可以模拟网络延时，倒计时等
- 每一个对象都有锁，sleep不会释放锁（线程抱着锁睡觉）
模拟网络延时
//模拟网络延时:放大问题的发生性
public class SleepTest implements Runnable{
//票数
private int ticketNums = 10;
@Override
public void run() {
while (true){
if (ticketNums<=0) break;
//模拟延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"张票");
}
}
public static void main(String[] args) {
SleepTest ticket = new SleepTest();
new Thread(ticket,"小米").start();
new Thread(ticket,"京东").start();
new Thread(ticket,"淘宝").start();
}
}
模拟倒计时，显示当前系统时间
package com.monki.javathread;
import java.text.SimpleDateFormat;
import java.util.Date;
//模拟倒计时
public class SleepTest2 {
public static void main(String[] args) {
//打印当前系统时间
Date startTime = new Date(System.currentTimeMillis());
while (true){
try{
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
startTime = new Date(System.currentTimeMillis());
}catch (Exception e){
e.printStackTrace();
}
}
}
public static void tenDown() throws InterruptedException {
int num = 10;
while (true){
Thread.sleep(1000);
System.out.println(num--);
if(num<=0){
break;
}
}
}
}
线程礼让
- 礼让线程，让当前正在执行的线程停止，但不阻塞
- 将线程从运行状态转为调度状态
- 让CPU重新迪奥顿，礼让不一定成功!看CPU心情
简单来说：就是在公交车上站起来起来重新抢座，不确定是否抢座成功。
线程强制执行
- 就是谁调用这个方法，就让调用此方法的线程进入阻塞状态，等待我执行完毕之后，再往下执行
package com.monki.javathread;
//测试Join方法：插队
public class JoinTest implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("线程"+Thread.currentThread().getName()+"来了"+i);
}
}
public static void main(String[] args) throws InterruptedException {
JoinTest joinTest = new JoinTest();
Thread thread = new Thread(joinTest,"vip");
Thread thread2 = new Thread(joinTest,"2");
thread.start();
thread.join();
thread2.start();
//主线程
for (int i = 0; i < 1000; i++) {
System.out.println("main"+i);
if(i==200){
thread.join();//插队
}
}
}
}