1、线程简介
1.1、普通方法和多线程的区别:
1.2、Process与Thread:
◆ 说起进程,不得不说下程序。程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。
◆ 而进程则是执行程序的一次执行过程,它是一个动态的概念。是系统资源分配的单位
◆ 通常在一个进程中可以包含若干个线程。当然一个进程中至少有一个线程,不然没有存在的意义。线程是CPU调度和执行的单位。
◆ 注意:
很多多线程是模拟出来的,真正的多线程是指有多个cpu,即多核,如服务器。如果是模拟出来的多线程,即在一个cpu的情况下,在同一个时间点,cpu只能执行一个代码,因为切换的很快,所以就有同时执行的错觉。
1.3、核心概念
◆ 线程就是独立的执行路径
◆ 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程,gc线程
◆ main() 称之为主线程,为系统的入口,用于执行整个程序
◆ 在一个线程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统紧密相关的,先后顺序是不能人为的干预的
◆ 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制
◆ 线程会带来额外的开销,如cpu调度时间,并发控制开销
◆ 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致
2、线程实现(重点)
Thread、Runnable、Callable
2.1、三种创建方式
2.2、Thread
◆ 自定义线程类继承Thread类具备多线程能力
◆ 重写run()方法,编写线程执行体
◆ 创建线程对象,调用start()方法启动线程
◆ 注意:线程开启不一定执行,由cpu调度执行
◆ 不建议使用:避免OOP单继承局限性
-
案例:
//创建线程方式一:继承Thread类,重写run()方法,调用start()方法开启线程 public class TestThread01 extends Thread{ @Override public void run() { //run()方法线程体 for (int i = 0; i < 10; i++) { System.out.println("我在看代码---"+i); } } public static void main(String[] args) { //main()线程,主线程 //创建一个线程对象 TestThread01 testThread01 = new TestThread01(); //调用start()方法开启线程 testThread01.start(); for (int i = 0; i < 10; i++) { System.out.println("我在学习多线程---"+i); } } }
案例:下载网络图片
package com.fy.demo01; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; //练习 thread ,实现多线程同步下载图片 public class TestThread02 extends Thread{ private String url; //网络图片地址 private String name; //保存的文件名 public TestThread02(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) { TestThread02 t1 = new TestThread02("https://bkimg.cdn.bcebos.com/pic/0df3d7ca7bcb0a46f21f74b20b35e1246b600d3301bb?x-bce-process=image/resize,m_lfit,w_536,limit_1","CR701.jpg"); TestThread02 t2 = new TestThread02("https://bkimg.cdn.bcebos.com/pic/0df3d7ca7bcb0a46f21f74b20b35e1246b600d3301bb?x-bce-process=image/resize,m_lfit,w_536,limit_1","CR702.jpg"); TestThread02 t3 = new TestThread02("https://bkimg.cdn.bcebos.com/pic/0df3d7ca7bcb0a46f21f74b20b35e1246b600d3301bb?x-bce-process=image/resize,m_lfit,w_536,limit_1","CR703.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.3、Runnable
◆ 定义MyRunnable类实现Runnable接口具备多线程能力
◆ 实现run()方法,编写线程执行体
◆ 创建线程对象,调用start()方法启动线程
◆ 推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用
-
案例:
package com.fy.demo01; //创建线程方法2:实现 Runnable 接口,重写 run() 方法,执行线程需要丢入 Runnable 接口实现类,调用start方法 public class TestThread03 implements Runnable{ @Override public void run() { //run()方法线程体 for (int i = 0; i < 10; i++) { System.out.println("我在看代码---"+i); } } public static void main(String[] args) { //创建 Runnable 接口的实现类对象 TestThread03 testThread03 = new TestThread03(); //创建线程对象,通过线程对象来开启线程,代理 // Thread thread = new Thread(testThread03); // // thread.start(); new Thread(testThread03).start(); for (int i = 0; i < 20; i++) { System.out.println("我在学习多线程---"+i); } } }
案例:买火车票
package com.fy.demo01; //多个线程同时操作同一个对象 //买火车票的例子 //发现问题:多个线程操作同一个资源的情况下,线程不安全,数据紊乱 public class TestThread04 implements Runnable{ //票数 private int ticketNums = 10; @Override public void run() { while (true) { if (ticketNums<=0) { break; } //模拟延时 try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "张票"); } } public static void main(String[] args) { TestThread04 testThread04 = new TestThread04(); new Thread(testThread04,"小明").start(); new Thread(testThread04,"老师").start(); new Thread(testThread04,"黄牛党").start(); } }
案例:龟兔赛跑
package com.fy.demo01; //模拟龟兔赛跑 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 + "步"); } } //判断比赛是否结束 public 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.4、Callable(了解即可)
◆ 实现Callable接口,需要返回值类型
◆ 重写call方法,需要抛出异常
◆ 创建目标对象
◆ 创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);
◆ 提交执行:Future<Boolean> result1 = ser.submit(t1);
◆ 获取结果:boolean r1 = result1.get()
◆ 关闭服务:ser.shutdownNow();
-
案例:
package com.fy.demo02; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; import java.util.concurrent.*; //创建线程方式3:实现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; } //下载图片线程的执行体 @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 { TestCallable t1 = new TestCallable("https://bkimg.cdn.bcebos.com/pic/0df3d7ca7bcb0a46f21f74b20b35e1246b600d3301bb?x-bce-process=image/resize,m_lfit,w_536,limit_1","CR701.jpg"); TestCallable t2 = new TestCallable("https://bkimg.cdn.bcebos.com/pic/0df3d7ca7bcb0a46f21f74b20b35e1246b600d3301bb?x-bce-process=image/resize,m_lfit,w_536,limit_1","CR702.jpg"); TestCallable t3 = new TestCallable("https://bkimg.cdn.bcebos.com/pic/0df3d7ca7bcb0a46f21f74b20b35e1246b600d3301bb?x-bce-process=image/resize,m_lfit,w_536,limit_1","CR703.jpg"); //创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(3); //提交执行 Future<Boolean> result1 = ser.submit(t1); Future<Boolean> result2 = ser.submit(t2); Future<Boolean> result3 = ser.submit(t3); //获取结果 boolean r1 = result1.get(); boolean r2 = result2.get(); boolean r3 = result3.get(); System.out.println(r1); System.out.println(r2); System.out.println(r3); //关闭服务 ser.shutdownNow(); } } //下载器 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.5、静态代理
-
案例:
package com.fy.staticproxy; //静态代理模式 //总结: //真实对象 和 代理对象 都要实现同一个接口 //代理对象要代理真实角色 //好处: //代理对象可以做很多真实对象做不了的事情 //真实对象专注做自己的事情 public class StaticProxy { public static void main(String[] args) { // WeddingCompany weddingCompany = new WeddingCompany(new You()); // weddingCompany.HappyMarry(); new WeddingCompany(new You()).HappyMarry(); new Thread( ()-> System.out.println("你要结婚了")).start(); } } 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() { befor(); this.target.HappyMarry();//这就是真实对象 after(); } private void befor() { System.out.println("结婚之前,布置现场"); } private void after() { System.out.println("结婚之后,收尾款"); } }
2.6、Lambda表达式
◆ λ希腊字母表中排序第十一位的字母,英语名称为 Lambda
◆ 避免匿名内部类定义过多
◆ 其实质属于函数式编程的概念
a-System.out.println("i like lambda-->" + a); new Thread(()->System.out.println("多线程学习...")).start();
-
为什么要使用 lambda表达式
1)避免匿名内部类定义过多
2)可以让你的代码看起来很简洁
3)去掉了一堆没有意义的代码,只留下核逻辑
也许你会说,我看了 Lambda表达式,不但不觉得简洁,反而觉得更乱,看不懂了。那是因为我们还没有习惯,用的多了,看习惯了,就好了。
◆ 理解Functional Interface (函数式接口)是学习Java8 lambda表达式的关键所在。
◆ 函数式接口的定义:
-
任何接口,如果只包含唯一一个抽象方,那么它就是一个函数式接口。
-
对于函数式接口,我们可以通过lambda表达式来创建该接口的对象。
案例:
package com.fy.lambda; /* 推导 Lambda表达式 */ public class TestLambda01 { //3.静态内部类 static class Like02 implements ILike{ @Override public void lambda() { System.out.println("I like lambda02"); } } public static void main(String[] args) { ILike like = new Like(); like.lambda(); like = new Like02(); like.lambda(); //4.局部内部类 class Like03 implements ILike{ @Override public void lambda() { System.out.println("I like lambda03"); } } like = new Like03(); like.lambda(); //5.匿名内部类,没有类的名称,必须借助接口或者父类 like = new ILike() { @Override public void lambda() { System.out.println("I like lambda04"); } }; like.lambda(); //6.用 Lambda 简化 like = ()->{ System.out.println("I like lambda05"); }; like.lambda(); } } //1.定义一个接口 interface ILike{ void lambda(); } //2.实现类 class Like implements ILike{ @Override public void lambda() { System.out.println("I like lambda"); } }
package com.fy.lambda; public class TestLambda02 { public static void main(String[] args) { ILove love = null; // //1.lambda简化 // ILove love = (int a)->{ // System.out.println("我爱你~!" + a); // }; //简化1:去掉参数类型 love = (a,b)->{ System.out.println("我爱你~!" + a + b); }; //简化2:去掉括号 // love = a -> { // System.out.println("我爱你~!" + a); // }; //简化3:去掉花括号 // love = a -> System.out.println("我爱你~!" + a); love.love(521,520); //总结: //1.lambda表达式只有一行代码的情况下,才能简化成一行,否则用代码块(花括号)包裹 //2.前提是接口为函数式接口 //3.多个参数也以去掉参数类型,要去掉都去掉 } } interface ILove{ void love(int a,int b); }
3、线程状态
五大状态:
3.1、线程方法
3.2、停止线程
◆ 不推荐使用JDK提供的stop()、destroy()方法。[已废弃]
◆ 推荐线程自己停止下来
◆ 建议使用一个标志位进行终止变量当flag=false,则终止线程运行
-
案例:
package com.fy.state; //测试线程停止---stop //1.建议线程正常停止--->利用次数,不建议死循环 //2.建议使用标志位--->设置一个标志位 //3.不要使用 stop 或者 destroy 等过时或者JDK不建议使用的方法 public class TestStop implements Runnable{ //1.设置一个标识位 private boolean flag = true; @Override public void run() { int i = 0; while (flag) { System.out.println("run...Thead " + i++); } } //2.设置一个公开的方法停止线程,转换标识位 public void stop() { this.flag = false; } public static void main(String[] args) { TestStop testStop = new TestStop(); new Thread(testStop).start(); for (int i = 0; i < 100; i++) { System.out.println("main " + i); if (i==80) { testStop.stop(); System.out.println("线程停止~ " + i); } } } }
3.3、线程休眠
◆ sleep(时间)指定当前线程阻塞的毫秒数
◆ sleep存在异常InterruptedException
◆ sleep时间达到后线程进入就绪状态
◆ sleep可以模拟网络延时,倒计时等
◆ 每一个对象都有一个锁,sleep不会释放锁
-
案例:
package com.fy.state; import java.text.SimpleDateFormat; import java.util.Date; //模拟网络延时:放大问题的发生性 //模拟倒计时 public class TestSleep02 { public static void main(String[] args) throws InterruptedException { //tenDown(); //打印当前系统时间 Date startTime = new Date(System.currentTimeMillis()); //获取系统当前时间 while (true) { Thread.sleep(1000); System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime)); startTime = new Date(System.currentTimeMillis()); //更新系统当前时间 } } //模拟倒计时 public static void tenDown() throws InterruptedException { int num = 10; while (true) { Thread.sleep(1000); System.out.println(num--); if (num<=0) { break; } } } }
3.4、线程礼让
◆ 礼让线程,让当前正在执行的线程暂停,但不阻塞
◆ 将线程从运行状态转为就绪状态
◆ 让cpu重新调度,礼让不一定成功!看CPU心情
-
案例:
package com.fy.state; //测试线程礼让 // 礼让不一定成功,看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 implements Runnable { @Override public void run() { System.out.println(Thread.currentThread().getName() + "线程开始执行~"); Thread.yield(); //礼让 System.out.println(Thread.currentThread().getName() + "线程停止执行~"); } }
3.5、线程强制执行——Join
◆ Join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞。
◆ 可以想象成插队
-
案例:
package com.fy.state; //测试 Join 方法,想象为插队 public class TestJoin implements Runnable{ @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("线程Vip来了 " + i); } } public static void main(String[] args) throws InterruptedException { //启动线程 TestJoin testJoin = new TestJoin(); Thread thread = new Thread(testJoin); //主线程 for (int i = 0; i < 500; i++) { if (i==200) { thread.start(); thread.join(); //插队 } System.out.println("main " + i); } } }
3.6、线程状态观测
◆ Thread.State
线程状态:线程可以处于以下状态之一:
-
NEW
尚未启动的线程处于此状态
-
RUNNABLE
在Java虛拟机中执行的线程处于此状态
-
BLOCKED
被阻塞等待监视器锁定的线程处于此状态
-
WAITING
正在等待另一个线程执行特定动作的线程处于此状态
-
TIMED_WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
-
TERMINATED
已退出的线程处于此状态
◆ 一个线程可以在给定时间点处于一个状态,这些状态是不反映任何操作系统线程状态的虚拟机状态。
-
案例:
package com.fy.state; //观察测试线程状态 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); //Run while (state != Thread.State.TERMINATED) { Thread.sleep(100); state = thread.getState(); //更新线程状态 System.out.println(state); //输出状态 } } }
3.7、线程优先级
◆ Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行。
◆ 线程的优先级用数字表示,范围从1~10
-
Thread.MIN_PRIORITY = 1
-
Thread.MAX_PRIORITY = 10
-
Thread.NORM_PRIORITY = 5
◆ 使用以下方式改变或获取优先级
-
getPriority().setPriority(int xxx)
◆ 优先级的设定建议在 start() 调度前
◆ 注意:优先级低只是意味着获得调度的概率低,并不是优先级低就不会被调用了,这都是看CPU的调度。
3.8、守护(daemon)线程
◆ 线程分为用户线程和守护线程
◆ 虚拟机必须确保用户线程执行完毕
◆ 虚拟机不用等待守护线程执行完毕
◆ 如,后台记录操作日志,监控内存,垃圾回收等待...
-
案例:
package com.fy.state; //测试守护线程 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 implements Runnable { @Override public void run() { while (true) { System.out.println("上帝保护着你"); } } } //你 class You implements Runnable { @Override public void run() { for (int i = 0; i < 36500; i++) { System.out.println("你一生都开心的活着 " + i); } System.out.println("====goodbye world!===="); } }
4、线程同步(synchronized)
多个线程操作同一个资源
4.1、并发
同一个对象被多个线程同时操作
◆ 例如:
◆ 现实生活中,我们会遇到“同一个资源,多个人都想使用“的问题,比如,食堂排队打饭,每个人都想吃饭,最天然的解决办法就是,排队一个一个来。
◆ 处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象,这时候我们就需要线程同步,线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用。
4.2、队列和锁
线程同步形成条件:队列和锁(保证线程同步的安全性)
◆ 由于同一进程的多个线程共享同一块存储空间,在带来方便的同时也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排它锁,独占资源,其他线程必须等待,使用后释放锁即可,存在以下问题:
1)一个线程持有锁会导致其他所有需要此锁的线程挂起
2)在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题
3)如果一个优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置,引起性能问题
4.3、同步方法
◆ 由于我们可以通过private关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字,它包括两种用法:synchronized方法和synchronized块。
同步方法:public synchronized void method(int args) {}
◆ synchronized方法控制对“对象”的访问,每个对象对应一把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行。
缺陷:若将一个大的方法申明为synchronized将会影响效率
-
弊端
-
案例:
package com.fy.synchronized_; //不安全的买票 //线程不安全,买到同一张票,有负数 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket station = new BuyTicket(); new Thread(station,"苦逼的我").start(); new Thread(station,"牛逼的你").start(); new Thread(station,"可恶的黄牛党").start(); } } class BuyTicket implements Runnable { //票 private int ticketNums = 10; boolean flag = true; //外部停止 @Override public void run() { //买票 while (flag) { buy(); //模拟延时 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } //synchronized 同步方法,锁的是this,保证线程安全 private synchronized void buy() { //判断是否有票 if (ticketNums<=0) { flag = false; return; } //买票 System.out.println(Thread.currentThread().getName() + "拿到了第 " + ticketNums-- + " 张票"); } }
4.4、同步块
◆ 同步块:synchronized (Obj ){ }
◆ Obj称之为同步监视器:
1)Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
2)同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this,就是这个对象本身,或者是class [反射中讲解]
◆ 同步监视器的执行过程:
-
第一个线程访问,锁定同步监视器,执行其中代码
-
第二个线程访问,发现同步监视器被锁定,无法访问
-
第一个线程访问完毕,解锁同步监视器
-
第二个线程访问,发现同步监视器没有锁,然后锁定并访问
-
案例:
package com.fy.synchronized_; //不安全的取钱 //两个人去银行取钱 public class UnsafeBank { public static void main(String[] args) { //账户 Account account = new Account(100,"结婚基金"); Drawing you = new Drawing(account,50,"你"); Drawing girlFriend = new Drawing(account,100,"girlFriend"); you.start(); girlFriend.start(); } } //账户 class Account { int money; //余额 String name; //卡名 public Account(int money, String name) { this.money = money; this.name = name; } } //银行:模拟取款 class Drawing extends Thread { //账户 Account account; //取了多少钱 int drawingMoney; //现在手里有多少钱 int nowMoney; public Drawing(Account account,int drawingMoney,String name) { super(name); this.account = account; this.drawingMoney = drawingMoney; } //取钱 @Override public void run() { //锁的是变化的量,在账户里面进行增删改查,锁的是账户 synchronized (account) { //判断有没有钱 if (account.money-drawingMoney<0) { System.out.println(Thread.currentThread().getName() + "余额不足,取不了"); return; } //sleep放大问题的发生性 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //卡内余额 = 余额 - 你取的钱 account.money = account.money - drawingMoney; //手里的钱 nowMoney = nowMoney + drawingMoney; System.out.println(account.name + "余额为:" + account.money); //Thread.currentThread().getName() = this.getName() System.out.println(this.getName() + "手里的钱:" + nowMoney); } } }
4.5、死锁
◆ 多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题。
-
产生死锁的四个必要条件:
-
互斥条件:一个资源每次只能被一个进程使用
-
请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放
-
不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺
-
循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系
-
避免方法:
上面列出了死锁的四个必要条件,我们只要想办法破其中的任意一个或多 个条件就可以避免死锁发生。
-
案例:
package com.fy.synchronized_; //死锁:多个线程互相抱着对方需要的资源,然后形成僵持 public class DeadLock { public static void main(String[] args) { Makeup g1 = new Makeup(0,"灰姑娘"); Makeup g2 = new Makeup(1,"白雪公主"); g1.start(); g2.start(); } } //口红 class Lipstick { } //镜子 class Mirror { } //化妆 class Makeup extends Thread { //需要的资源只有一份,用static来保证只有一份 static Lipstick lipstick = new Lipstick(); static Mirror mirror = new Mirror(); int choice; //选择 String girlName; //使用化妆品的人 public Makeup (int choice,String girlName) { this.choice = choice; this.girlName = girlName; } @Override public void run() { //化妆 try { makeup(); } catch (InterruptedException e) { e.printStackTrace(); } } //化妆,相互持有对方的资源,就是需要拿到对方的资源,才能工作 private void makeup() throws InterruptedException { if (choice==0) { synchronized (lipstick) { //获得口红的锁 System.out.println(this.girlName + "获得口红的锁"); Thread.sleep(1000); } synchronized (mirror) { //一秒钟后想获得镜子的锁 System.out.println(this.girlName + "获得镜子的锁"); } }else { synchronized (mirror) { //获得镜子的锁 System.out.println(this.girlName + "获得镜子的锁"); Thread.sleep(2000); } synchronized (lipstick) { //两秒钟后想获得口红的锁 System.out.println(this.girlName + "获得口红的锁"); } } //死锁 // if (choice==0) { // synchronized (lipstick) { //获得口红的锁 // System.out.println(this.girlName + "获得口红的锁"); // Thread.sleep(1000); // synchronized (mirror) { //一秒钟后想获得镜子的锁 // System.out.println(this.girlName + "获得镜子的锁"); // } // } // }else { // synchronized (mirror) { //获得镜子的锁 // System.out.println(this.girlName + "获得镜子的锁"); // Thread.sleep(2000); // synchronized (lipstick) { //两秒钟后想获得口红的锁 // System.out.println(this.girlName + "获得口红的锁"); // } // } // } } }
4.6、Lock(锁)
◆ 从JDK5.0开始,Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
◆ java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。
◆ ReentrantLock 类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁、释放锁。
-
案例:
package com.fy.senior; import java.util.concurrent.locks.ReentrantLock; public class TestLock { public static void main(String[] args) { TestLock02 testLock02 = new TestLock02(); new Thread(testLock02).start(); new Thread(testLock02).start(); new Thread(testLock02).start(); } } class TestLock02 implements Runnable { private int ticketNums = 10; //定义lock锁 private final ReentrantLock lock = new ReentrantLock(); @Override public void run() { try { lock.lock(); //加锁 while (true) { if (ticketNums>0) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(ticketNums--); }else { break; } } } finally { lock.unlock(); //解锁 } } }
4.7、synchronized 和 lock 的对比
◆ Lock是显式锁(手动开启和关闭锁,别忘记关闭锁),synchronized是隐式锁,出了作用域自动释放
◆ Lock只有代码块锁,synchronized有代码块锁和方法锁
◆ 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)
◆ 优先使用顺序:
Lock > 同步代码块(已经进入了方法体,分配了相应资源)> 同步方法(在方法体之外)
5、线程通信问题
生产者消费者模式(并不是23种设计模式之一)
◆ 应用场景:生产者和消费者问题
1)假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费。
2)如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止。
3)如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止。
5.1、分析
◆ 这是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间相互依赖,互为条件。
1)对于生产者,没有生产产品之前,要通知消费者等待,而生产了产品之后,又需要马上通知消费者消费。
2)对于消费者,在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费。
◆ 在生产者消费者问题中,仅有synchronized是不够的
1)synchronized可阻止并发更新同一个共享资源,实现了同步
2)synchronized不能用来实现不同线程之间的消息传递(通信)
◆ Java提供了几个方法解决线程之间的通信问题
注意:均是Object类的方法,都只能在同步方法或者同步代码块中使用,否则会抛出异常legalMonitorStateException
5.2、解决方式1
-
并发协作模型“生产者/消费者模式”—>管程法
◆ 生产者:负责生产数据的模块(可能是方法,对象,线程,进程)
◆ 消费者:负责处理数据的模块(可能是方法,对象,线程,进程)
◆ 缓冲区:消费者不能直接使用生产者的数据,他们之间有个“缓冲区生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据
-
案例:
package com.fy.senior; //测试:生产者消费者模式--->利用缓冲区解决:管程法 //生产者 消费者 产品 缓冲区 public class TestPC { public static void main(String[] args) { SynContainer container = new SynContainer(); new Producer(container).start(); new Consumer(container).start(); } } //生产者 class Producer extends Thread { SynContainer container; public Producer(SynContainer container) { this.container = container; } //生产 @Override public void run() { for (int i = 1; i < 100; i++) { container.push(new Chicken(i)); System.out.println("生产了" + i + "只鸡"); } } } //消费者 class Consumer extends Thread { SynContainer container; public Consumer(SynContainer container) { this.container = container; } //消费 @Override public void run() { for (int i = 1; i < 100; i++) { System.out.println("消费了--->" + container.pop().id + "只鸡"); } } } //产品 class Chicken { int id; //产品编号 public Chicken(int id) { this.id = id; } } //缓冲区 class SynContainer { //需要一个容器大小 Chicken[] chickens = new Chicken[10]; //容器计数器 int count = 0; //生产者放入产品 public synchronized void push(Chicken chicken) { //如果容器满了,就需要等待消费者消费 if (count== chickens.length) { //生产者等待 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果没有满,就需要放入产品 chickens[count] = chicken; count++; //可以通知消费者消费了 this.notifyAll(); } //消费者消费产品 public synchronized Chicken pop() { //判断能否消费 if (count==0) { //消费者等待 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果可以消费 count--; Chicken chicken = chickens[count]; //吃完了,通知生产者生产 this.notifyAll(); return chicken; } }
5.3、解决方式2
-
并发协作模型“生产者/消费者模式”—>信号灯法
-
案例:
package com.fy.senior; //测试:生产者消费者模式--->信号灯发,标志位解决 public class TestPC02 { public static void main(String[] args) { TV tv = new TV(); new Player(tv).start(); new Watcher(tv).start(); } } //生产者:演员 class Player extends Thread { TV tv; public Player(TV tv) { this.tv = tv; } @Override public void run() { for (int i = 0; i < 20; i++) { if (i%2==0) { this.tv.play("电影"); }else { this.tv.play("抖音"); } } } } //消费者:观众 class Watcher extends Thread { TV tv; public Watcher(TV tv) { this.tv = tv; } @Override public void run() { for (int i = 0; i < 20; i++) { this.tv.watch(); } } } //产品:节目 class TV { //演员表演,观众等待 T //观众观看,演员等待 F String voice; //表演的节目 Boolean flag = true; //表演 public synchronized void play(String voice) { //演员等待 if (!flag) { try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("演员表演了:" + voice); //通知观众观看 this.notifyAll(); //通知唤醒 this.voice = voice; this.flag = !this.flag; } //观看 public synchronized void watch() { if (flag) { try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("观众观看了:" + voice); //通知演员表演 this.notifyAll(); this.flag = !this.flag; } }
6、线程池
◆ 背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
◆ 思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
◆ 好处:
-
提高响应速度(减少了创建新线程的时间)
-
降低资源消耗(重复利用线程池中线程,不需要每次都创建)
-
便于线程管理(...)
1)corePoolSize:核心池的大小
2)maximumPoolSize:最大线程数
3)keepAliveTime:线程没有任务时最多保持多长时间后会终止
◆ JDK5.0起提供了线程池相关API:ExecutorService 和 Executors
◆ ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor:
-
void execute(Runnable command):执行任务/命令,没有返回值,一般用来执行Runnable
-
<T>Future<T> submit(Callable<T> task):执行任务,有返回值,一般用来执行Callable
-
void shutdown():关闭连接池
◆ Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池
-
案例:
package com.fy.senior; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; //测试线程池 public class TestPool { public static void main(String[] args) { //1.创建服务,创建线程池 //newFixedThreadPool:参数为 线程池的大小 ExecutorService service = Executors.newFixedThreadPool(10); //2.执行 service.execute(new MyThead()); service.execute(new MyThead()); service.execute(new MyThead()); service.execute(new MyThead()); //3.关闭链接 service.shutdown(); } } class MyThead implements Runnable { @Override public void run() { System.out.println(Thread.currentThread().getName()); } }