1、多线程
核心概念
-
说起进程，就不得不说一下程序。程序的指令和数据的有序集合，其本身都没有任何运行的含义，是一个静态的概念
-
而进程则是执行程序的一次执行过程，他是一个动态的概念，是系统资源分配的单位
-
通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位
- 注意：很多多线程是模拟出来的，正在的多线程是指 有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉
-
线程就是独立的执行路径
-
在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程
-
main()称之为主线程，为系统的入口，用于执行整个程序
-
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
-
线程会带来额外的开销，如cpu调度时间，并发控制开销
-
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
2、Thread
-
- 自定义线程类继承Thread类
- 重写run()方法、编写线程执行体
- 创建线程对象，调用start()方法启动线程
注意：线程不一样立即执行，CPU安排调度
package com.demo01;//创建线程方式一：继承Thread类、重写run()方法、调用start开启线程//总结：注意，线程开启不一定立即执行，由CPU调度
public class TextThread01 extends Thread{@Overridepublic void run() {//run方法线程体for (int i = 0; i < 200; i++) {System.out.println("我在看代码---> " + i);}}public static void main(String[] args) {//main线程 主线程//创建一个线程对象TextThread01 textThread01 = new TextThread01();//调用start()方法开启线程textThread01.start();for (int i = 0; i < 1000; i++) {System.out.println("我在学习多线程---> " + i);}}
}
补充：网图下载
图片链接不能是本地电脑里面文件的链接
package com.demo01;import org.apache.commons.io.FileUtils;import java.io.File;
import java.io.IOException;
import java.net.URL;//练习Thread，实现多线程同步下载图片
public class TextThread02 extends Thread{private String url; //网络照片地址private String name; //保存的文件名public TextThread02(String url,String name){this.url = url;this.name = name;}//下载图片线程的执行体@Overridepublic void run() {WebDownloader webDownloader = new WebDownloader();webDownloader.downloader(url,name);System.out.println("下载了文件名为：" + name);}public static void main(String[] args) {TextThread02 textThread01 = new TextThread02("https://img.zcool.cn/community/01e0645db982f8a801209e1ff801d3.jpg?x-oss-process=image/auto-orient,1/resize,m_lfit,w_1280,limit_1/sharpen,100","1.jpg");textThread01.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方法出现问题");}}
}
3、Runnable
package com.demo01;//创建线程方式2：实现runnable接口，重写run()方法，执行线程需要丢入runnable接口实现类，调用start()方法
public class TextThread03 implements Runnable{@Overridepublic void run() {//run方法线程体for (int i = 0; i < 200; i++) {System.out.println("我在看代码---> " + i);}}public static void main(String[] args) {//创建runnable接口的实现类对象TextThread03 textThread03 = new TextThread03();//创建线程对象，通过线程对象来开启我们的线程，代理
// Thread thread = new Thread(textThread03);
// thread.start();new Thread(textThread03).start();for (int i = 0; i < 1000; i++) {System.out.println("我在学习多线程---> " + i);}}
}
小结：
-
继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程：子类对象.start()
- 不建议使用：避免OOP单继承局限性
-
实现Runnable接口
- 实现接口Runnable具有多线程能力
- 启动线程：传入目标对象 + Thread对象.start
- 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
初识并发问题：
package com.demo01;//多个线程同时操作一个对象
//买火车票//发现问题：多个线程同时操作一个资源的情况下，线程不安全，数据紊乱
public class TextThread04 implements Runnable{private int ticketNums = 1;@Overridepublic void run() {while (true){if (ticketNums > 100) {break;}System.out.println(Thread.currentThread().getName() + "--> 正在售卖第 " + ticketNums++ + "张票");}}public static void main(String[] args) {TextThread04 textThread04 = new TextThread04();new Thread(textThread04,"窗口1").start();new Thread(textThread04,"窗口2").start();new Thread(textThread04,"黄牛").start();}
}
但是并没有出现线程重复的问题？
案例：龟兔赛跑
package com.demo01;public class TextRace implements Runnable{private static String winner;@Overridepublic void run() {for (int i = 0; i <= 100; i++) {//模拟兔子睡觉休息if (Thread.currentThread().getName().equals("兔子") && i %10 == 0){try {Thread.sleep(10);} 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;if (steps >= 100) {winner = Thread.currentThread().getName();System.out.println("The Winner is " + winner);return true;}return false;}public static void main(String[] args) {TextRace textRace = new TextRace();new Thread(textRace,"兔子").start();new Thread(textRace,"乌龟").start();}
}
4、实现Callable接口
- 实现Callable接口，需要返回值类型
- 重写call方法，需要抛出异常
- 创建目标对象
- 创建执行服务：ExecutorService = Executors.newFixedThreadPool(1);
- 提交执行：Future
result1 = ser.submint(i); - 获取结果：boolean r1 = result1.get();
- 关闭服务：set.shutdownNow();
package com.demo02;import com.L.OOP.demo10.Text;
import org.apache.commons.io.FileUtils;import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;/*
线程创建方式三：实现Callable接口Callable的好处
1. 可以定义返回值
2. 可以抛出异常*/
public class TextCallable implements Callable<Boolean> {private String url;private String name;public TextCallable(String url,String name) {this.url = url;this.name = name;}@Overridepublic 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 {TextCallable textCallable01 = new TextCallable("https://p2.ssl.img.360kuai.com/t01daff7de15d101ad0.jpg","tw01.jpg");TextCallable textCallable02 = new TextCallable("https://c-ssl.duitang.com/uploads/item/202003/02/20200302221741_rispl.jpeg","tw02.jpg");TextCallable textCallable03 = new TextCallable("https://ts1.cn.mm.bing.net/th/id/R-C.443ecfa611bca21986df8ff485ad2f3f?rik=iIjw6o6Ehu4Odw&riu=http%3a%2f%2fattach.hunantv.com%2fuploads%2fimages%2fcms_img%2f201111%2f24%2f10%2f5780486696986371858.jpg&ehk=0xuVP55K0U77h4UArHx4YqHRJhyxS3p6wMFcz5XDkJc%3d&risl=&pid=ImgRaw&r=0","tw03.jpg");//创建执行服务ExecutorService executorService = Executors.newFixedThreadPool(3);//提交执行Future<Boolean> result01 = executorService.submit(textCallable01);Future<Boolean> result02 = executorService.submit(textCallable02);Future<Boolean> result03 = executorService.submit(textCallable03);//获取结果boolean returnResourceResult01 = result01.get();boolean returnResourceResult02 = result02.get();boolean returnResourceResult03 = result03.get();System.out.println(returnResourceResult01);System.out.println(returnResourceResult02);System.out.println(returnResourceResult03);//关闭服务executorService.shutdown();}}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方法可能出现了异常");}}
}
5、静态代理模式
package com.demo03;//静态代理模式总结
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色//好处：//代理对象可以做很多真实对象做不了的事情//真实对象就专注做自己的事情public class StaticProxy {public static void main(String[] args) {You you = new You(); //你要结婚WeddingCompany weddingCompany = new WeddingCompany(you);weddingCompany.HappyMarry();}
}interface Marry {void HappyMarry();
}//真实角色：是你去结婚
class You implements Marry {@Overridepublic void HappyMarry() {System.out.println("小刘正在学习Java-->");}
}//代理角色：帮助你结婚
class WeddingCompany implements Marry {//代理谁--> 真实目标角色private Marry marryTarget;public WeddingCompany(Marry marryTarget) {this.marryTarget = marryTarget;}@Overridepublic void HappyMarry() {before();this.marryTarget.HappyMarry(); //这就是真实对象after();}private void before() {System.out.println("在学习Java之前需要交钱");}private void after() {System.out.println("在学习Java之后可以挣钱");}}
6、Lambda表达式
-
为什么要使用lambda表达式
- 避免匿名内部类定义过多
- 可以让你的代码看起来更简洁
- 去掉了一堆没有意义的代码，只留下核心的逻辑
-
理解Functional interface（函数式接口）
-
函数式接口的定义：
- 任何接口，如果包含唯一一个抽象方法，那么它就是一个函数式接口
public interface Runnable {public abstract void run();
}
- 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象
1、简化过程集合
package com.lambda;public class TextLambda {//静态内部类static class Like01 implements ILike {@Overridepublic void lambda() {System.out.println("The people which I like number01");}}public static void main(String[] args) {ILike like = new Like();like.lambda();like = new Like01();like.lambda();//局部内部类 把类放在方法里面class Like02 implements ILike {@Overridepublic void lambda() {System.out.println("The people which I like number02");}}like = new Like02();like.lambda();//匿名内部类 没有类的名称，必须接住接口或者父类like = new ILike() {@Overridepublic void lambda() {System.out.println("The people which I like number03");}};like.lambda();//用lambda简化like = () ->{System.out.println("The people which I like number04");};like.lambda();}
}interface ILike {void lambda();
}class Like implements ILike {@Overridepublic void lambda() {System.out.println("The people which I like number00");}
}
2、拆解理解
1. 最开始的方法：外部类实现接口，实例化
package com.lambda;public class TextLambda02 {public static void main(String[] args) {ILove01 iLove = new Love();iLove.love01("XXX");}
}interface ILove01{void love01(String a);
}class Love implements ILove01 {@Overridepublic void love01(String a) {System.out.println("I love you," + a);}
}
2. 静态内部类
package com.lambda;public class TextLambda03 {//静态内部类static class Love02 implements ILove02 {@Overridepublic void love02(String name) {System.out.println("I love you," + name);}}public static void main(String[] args) {ILove02 iLove02 = new Love02();iLove02.love02("XX");}
}interface ILove02 {void love02(String name);
}
3. 局部内部类
package com.lambda;public class TextLambda04 {public static void main(String[] args) {class Love04 implements ILove04 {@Overridepublic void love04(String name) {System.out.println("I love you," + name);}}ILove04 iLove04 = new Love04();iLove04.love04("X");}
}interface ILove04 {void love04(String name);
}
4. 匿名内部类
package com.lambda;public class TextLambda05 {public static void main(String[] args) {ILove05 iLove05 = new ILove05() {@Overridepublic void love05(String name) {System.out.println("I love you," + name);}};iLove05.love05("2333");}}interface ILove05 {void love05(String name);
}
5. lambda表达式
package com.lambda;public class TextLambda06 {public static void main(String[] args) {// //lambda表达式简化
// ILove06 iLove06 = (String name) ->{
// System.out.println("I love you," + name);
// };//简化1：参数类型(形参参数类型的简化)// ILove06 iLove06 = (name) ->{
// System.out.println("I love you," + name);
// }// //简化2：简化括号
// ILove06 iLove06 = name -> {
// System.out.println("I love you," + name);
// };//简化3：去掉花括号ILove06 iLove06 = name -> System.out.println("I love you," + name);iLove06.love06("23333");//总结：//lambda表达式只能在有一行代码的情况下简化为一行，其他情况需要使用代码块{}包裹//前提是接口为函数式接口(只有一个方法的接口)//多个参数也可以去掉参数类型，要去掉就都去掉，但是多个参数的情况下必须加上括号()}
}interface ILove06 {void love06(String name);
}
