多线程

• 多任务、多线程
• 程序、进程、线程
• 学着看jdk文档
• 线程的创建
• • 1.继承Thread类
  • 2.实现Runable接口
  • 理解并发的场景
  • 龟兔赛跑场景
  • 实现callable接口
• 理解函数式接口
• 理解线程的状态
• • 线程停止
  • 线程休眠sleep
  • • 1.网路延迟
    • 2.倒计时等
  • 线程礼让yield
  • 线程强制执行
• 观察线程状态
• 线程的优先级
• 守护线程
• 线程同步机制
• • 1.synchronized 同步方法
  • 2.同步块synchronized（Obj）{}
• lock
• synchronized与lock

多任务、多线程 在多任务场景下，两件事看上去同时在做，但实际上，你的大脑在同一时间只做一件事，间隔时间可能很少，但这似乎让你感觉这两件事是同时在做
考虑阻塞问题，引入多线程的场景，多线程并发场景

文章图片

程序、进程、线程 程序=指令+数据（静态的）
在操作系统中运行的程序就是进程，一个进程可以有多个线程
比如，看视频时听声音，看图像，看弹幕等
学着看jdk文档 比如你要看Thread
你可以搜索，然后阅读

文章图片

往下翻你会看到：

文章图片


文章图片


文章图片

线程的创建 1.继承Thread类

//创建线程方式一：继承Thread类,重写run方法，调用start()方法开启线程 public class TestThread1extends Thread{@Override public void run() {//run()方法线程体 IntStream.range(0,20).forEach(i->{System.out.println("我在看代码"+i); }); }public static void main(String[] args) {//创建一个线程对象 TestThread1 testThread1=new TestThread1(); //调用start()方法，启动线程，不一定立即执行，由cpu调度执行 testThread1.start(); //主方法 main方法 IntStream.range(0,20).forEach(i->{System.out.println("我在学习多线程"+i); }); } }

一个小练习：

//练习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() {WebDownload webDownload=new WebDownload(); webDownload.downloader(url,name); System.out.println("下载了文件名："+name); }public static void main(String[] args) {TestThread2 t1=new TestThread2("https://profile.csdnimg.cn/B/D/2/3_sxh06","1.jpg"); TestThread2 t2=new TestThread2("https://profile.csdnimg.cn/B/D/2/3_sxh06","2.jpg"); TestThread2 t3=new TestThread2("https://profile.csdnimg.cn/B/D/2/3_sxh06","3.jpg"); t1.start(); t2.start(); t3.start(); } }//下载器 class WebDownload{//下载方法 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.实现Runable接口

//创建线程的方法2：实现Runable接口 public class TestThread3 implements Runnable{@Override public void run() {//run()方法线程体 IntStream.range(0,20).forEach(i->{System.out.println("我在看代码"+i); }); }public static void main(String[] args) {//创建一个线程对象 TestThread3 testThread3=new TestThread3(); //调用start()方法，启动线程，不一定立即执行，由cpu调度执行 //Thread thread=new Thread(testThread3); //thread.start(); //或者这样简写 new Thread(testThread3).start(); //主方法 main方法 IntStream.range(0,100).forEach(i->{System.out.println("我在学习多线程"+i); }); } }

文章图片

理解并发的场景 当多个线程使用同一个资源时，会出现问题，看看下面这个买火车票的例子：

public class TestThread4 implementsRunnable{//票数 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,"李四").start(); } }

看看运行的结果：

文章图片

可以看到案例中的线程不安全问题，同时数据也是不正确的
龟兔赛跑场景

/** * 模拟龟兔赛跑 */ 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(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); return true; }else{return false; } }public static void main(String[] args) {Race race=new Race(); new Thread(race,"兔子").start(); new Thread(race,"乌龟").start(); } }

实现callable接口

//线程创建方式3 public class TestCallable implements Callable {private String url; private String name; public TestCallable(String url, String name) {this.url = url; this.name = name; }@Override public Boolean call() {com.sxh.thread.WebDownload webDownload=new com.sxh.thread.WebDownload(); webDownload.downloader(url,name); System.out.println("下载了文件名："+name); return true; }public static void main(String[] args) throws ExecutionException, InterruptedException {TestCallable t1=new TestCallable("https://profile.csdnimg.cn/B/D/2/3_sxh06","1.jpg"); TestCallable t2=new TestCallable("https://profile.csdnimg.cn/B/D/2/3_sxh06","2.jpg"); TestCallable t3=new TestCallable("https://profile.csdnimg.cn/B/D/2/3_sxh06","3.jpg"); //创建执行服务 ExecutorService ser= Executors.newFixedThreadPool(3); //提交执行 Future r1=ser.submit(t1); Future r2=ser.submit(t2); Future r3=ser.submit(t3); //获取结果 boolean rs1=r1.get(); boolean rs2=r2.get(); boolean rs3=r3.get(); //关闭服务 ser.shutdownNow(); }}

理解函数式接口 任何接口，只包含唯一一个抽象方法，就是函数式接口

/** * lambdab表达式的发展 */ public class TestLambda1 {//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"); } }

理解线程的状态
文章图片

线程停止

public class TestStop implements Runnable{//1.设置一个标志位 private boolean flag=true; @Override public void run() {int i=0; while (flag){System.out.println("run...thread.."+i++); } }//2.设置一个公开的方法停止线程，转换标志位 public void stop(){this.flag=false; }public static void main(String[] args) {TestStop stop=new TestStop(); new Thread(stop).start(); for (int i = 0; i < 1000; i++) {System.out.println("main"+i); if (i==900){//调用stop方法，让线程停止 stop.stop(); System.out.println("线程该停止了"); } } //IntStream.range(0,1000).forEach(i->{// //}); } }

线程休眠sleep 每个对象都有一把锁，sleep不会释放锁
1.网路延迟

//模拟延迟 try {Thread.sleep(200); //ms } catch (InterruptedException e) {e.printStackTrace(); }

2.倒计时等

public static void main(String[] args) {try {tendown(); } catch (InterruptedException 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; } } }

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 (InterruptedException e) {e.printStackTrace(); } } }

线程礼让yield

//线程礼让礼让不一定成功，由cpu重新调度 public class TestYield {public static void main(String[] args) {MyYield myYield=new MyYield(); new Thread(myYield,"a").start(); new Thread(myYield,"b").start(); } } class MyYield implementsRunnable{@Override public void run() {System.out.println(Thread.currentThread().getName()+"线程开始执行"); Thread.yield(); System.out.println(Thread.currentThread().getName()+"线程停止执行"); } }

线程强制执行

//测试join方法想象为插队 public class TestJoin implementsRunnable{@Override public void run() {for (int i = 0; i < 100; i++) {System.out.println("线程vip来了"+i); } }public static void main(String[] args) throws InterruptedException {//启动线程 TestJoin testJoin=new TestJoin(); Thread thread=new Thread(testJoin); thread.start(); //主线程 for (int i = 0; i < 1000; i++) {if (i==200){thread.join(); //插队 } System.out.println("main"+i); } } }

观察线程状态

public class TestState {public static void main(String[] args) throws InterruptedException {Thread thread=new Thread(()->{for (int i = 0; i < 5; i++) {try {Thread.sleep(1000); } catch (InterruptedException e) {e.printStackTrace(); } } System.out.println("//"); }); //观察状态 Thread.State state=thread.getState(); System.out.println(state); //NEW//启动后 thread.start(); state=thread.getState(); System.out.println(state); //Runwhile (state != Thread.State.TERMINATED) {Thread.sleep(100); state=thread.getState(); //更新线程状态 System.out.println(state); //Run } } }

线程的优先级

//测试线程的优先级 public class TestPriority {public static void main(String[] args) {//主线程默认优先级 System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority()); MyPriority myPriority=new MyPriority(); Thread t1=new Thread(myPriority); Thread t2=new Thread(myPriority); Thread t3=new Thread(myPriority); Thread t4=new Thread(myPriority); Thread t5=new Thread(myPriority); Thread t6=new Thread(myPriority); //先设置优先级，在启动 t1.start(); t2.setPriority(1); t2.start(); t3.setPriority(4); t3.start(); t4.setPriority(Thread.MAX_PRIORITY); t4.start(); t5.setPriority(-1); t5.start(); t6.setPriority(11); t6.start(); } } class MyPriority implements Runnable{@Override public void run() {System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority()); } }

守护线程 线程分为用户线程和守护线程

//测试守护线程 public class TestDaemon {public static void main(String[] args) {God god=new God(); You you=new You(); Thread thread=new Thread(god); thread.setDaemon(true); //默认是false表示用户线程 thread.start(); new Thread(you).start(); } }class God implementsRunnable{@Override public void run() {while (true){System.out.println("上帝保佑着你"); } } } class You implements Runnable{@Override public void run() {for (int i = 0; i < 36000; i++) {System.out.println("你活着"+i); } System.out.println("goodbye!!"); } }

线程同步机制 解决安全性问题：队列+锁
1.synchronized 同步方法 默认锁的是this,如需锁其他的，使用下面的同步块

//synchronized 同步方法 privatesynchronized void buy(){if (ticketNums<=0){flag=false; return; } //模拟延迟 try {Thread.sleep(100); } catch (InterruptedException e) {e.printStackTrace(); } //买票 System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"张票"); }

2.同步块synchronized（Obj）{} 【笔记|多线程基础】锁的对象是变化的量，需要增删改的对象
obj称之为同步监视器，即监视对象

public class UnsafeList {public static void main(String[] args) {List list=new ArrayList(); for (int i = 0; i < 10000; i++) {new Thread(()->{synchronized (list){list.add(Thread.currentThread().getName()); } }).start(); }try {Thread.sleep(3000); } catch (InterruptedException e) {e.printStackTrace(); } System.out.println(list.size()); } }

lock

class A{//ReentrantLock 可重入锁 private final ReentrantLock lock=new ReentrantLock(); public void f(){lock.lock(); //加锁 try{//..... } finally{lock.unlock(); //释放锁 } }}

synchronized与lock

1. lock是显示锁需要手动开关，synchronized是隐式锁，出了作用域自动释放
2. lock只有代码块锁，synchronized有代码块锁和方法锁
3. JVM将花费更少的时间来调度线程，性能更好，更有扩展性
4. 优先使用：Lock>同步代码块>同步方法

推荐阅读

• 

  五味
• 

  激光能去除肥胖纹吗视频 激光能去除肥胖纹吗
• 

  原味烤肉制作方法 原味烤肉的制作方法
• 

  房间里面有老鼠怎么办
• 

  有没有好点收益高的副业项目？
• 

  年收入是指纯收入，年收入是什么意思
• 

  松下洗衣机烘干为什么出水,首先原因要搞清
• 

  读地图分析,如何读地图获取信息
• 

  3d|2千档高质价比手机推荐：骁龙870+三星屏+65W，真我真牛
• 

  刑事自诉案件的范围是什么
• 

  生理盐水洗鼻子可以预防新冠肺炎吗
• 

  胚芽燕麦粥
• 

  辰辉的寓意
• 

  健康工作远离疼痛现在要坐好
• 

  被子晒多久比较好
• 

  头孢料酒会有反应吗
• 

  鹌鹑鸟怎么养 鹌鹑鸟如何饲养
• 

  人成长分为哪些阶段
• 

  如何鉴别建兰国魂真假 如何鉴别建兰国魂真假
• 

  回归模型结果分析方法,ABC态度模型分析方法和运用

• 放屁有这三个特征的，请注意啦！这说明你的身体毒素太多
• EffectiveObjective-C2.0|EffectiveObjective-C2.0 笔记 - 第二部分
• 爱就是希望你好好活着
• 昨夜小楼听风
• 知识
• 死结。
• 我从来不做坏事
• 烦恼和幸福
• 关于QueryWrapper|关于QueryWrapper,实现MybatisPlus多表关联查询方式
• Android中的AES加密-下