Day09多线程
多线程
原来是一条路，慢慢因为车太多了，道路堵塞，效率极低。为了提高使用的效率，能够充分利用道路，于是加了多个车道。从此，妈妈再也不用担心道路堵塞了。
普通方法调用多线程
一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕，等等
Process与Thread
- 程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念
- 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
- 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。
- 注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。
核心概念
- 线程就是独立的执行路径;
- 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程;
- main()称之为主线程，为系统的入口，用于执行整个程序;
- 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的。
- 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制;
- 线程会带来额外的开销，如CPU调度时间，并发控制开销。
- 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
线程创建方式
Thread class 需要去继承 Thread（重点）
-
自定义线程类 继承 Thread 类
-
重写 run() 方法，编写线程执行体
-
创建线程对象，调用 start() 方法启动线程
-
线程开启不一定立即执行，由CPU调度执行
-
//创建线程方式一 ： 继承Thread 类 ，重写run()方法，调用start 开启线程 public class TestThread1 extends Thread { @Override public void run() { for (int i = 0; i < 20; i++) { System.out.println("我在看代码-----"+i); } } public static void main(String[] args) { TestThread1 testThread1 = new TestThread1(); testThread1.start(); for (int i = 0; i < 20; i++) { System.out.println("我在学习---"+i); } } } -
//下载网络图片 import org.apache.commons.io.FileUtils; import java.io.File; import java.net.URL; //联系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() { WebDownLoader webDownLoader = new WebDownLoader(); webDownLoader.downloader(url,name); System.out.println("下载了文件名为："+name); } public static void main(String[] args) { TestThread2 t1 = new TestThread2("http://p2.music.126.net/u9XGx1GMmtLD0oFXEqxhjQ==/109951167131488756.jpg?param=140y140","1.jpg"); TestThread2 t2 = new TestThread2("http://p2.music.126.net/u9XGx1GMmtLD0oFXEqxhjQ==/109951167131488756.jpg?param=140y140","2.jpg"); TestThread2 t3 = new TestThread2("http://p2.music.126.net/u9XGx1GMmtLD0oFXEqxhjQ==/109951167131488756.jpg?param=140y140","3.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 (Exception e) { e.printStackTrace(); System.out.println("IO异常，downloader方法出现问题"); } } }
Runnable 接口 实现 Runnable 接口（重点）
- 定义 MyRunnable 类实现 Runnable 接口
- 实现 run() 方法，编写线程执行体
- 创建线程对象，调用 start() 方法启动线程
//创建线程方式一 ： 继承Thread 类 ，重写run()方法，调用start 开启线程
public class TestThread1 extends Thread {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码-----"+i);
}
}
public static void main(String[] args) {
TestThread1 testThread1 = new TestThread1();
testThread1.start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习---"+i);
}
}
}
小结：
- 继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程：子类对象.start()
- 不建议使用：避免OOP单继承局限性
- 实现Runnable接口
- 实现接口Runnable具有多线程能力
- 启动线程：传入目标对象+Thread对象.start()
- 推荐使用：避免单继承的局限性，灵活方便，方便同一个对象被多个线程使用
初识并发
//发现问题 多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class TestThread4 implements Runnable{
private int ticketNums = 10;
@Override
public void run() {
while (true){
if (ticketNums<=0){
break;
}
try {//模拟延时
Thread.sleep(200);
} catch (Exception 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();
}
}
Callable 接口 实现 Callable 接口（了解）
- 实现Callable接口，需要返回值类型
- 重写call方法，需要抛出异常
- 创建目标对象
- 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
- 提交执行：Future
result1 = ser.submit(t1); - 获取结果：boolean r1 = result1.get();
- 关闭服务：ser.shutdownNow();
import org.apache.commons.io.FileUtils;
import java.io.File;
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;
}
@Override
public Boolean call() {
WebDownLoader1 webDownLoader = new WebDownLoader1();
webDownLoader.downloader(url,name);
System.out.println("下载了文件名为："+name);
return true;
}
public static void main(String[] args) throws Exception {
TestCallable t1 = new TestCallable("http://p2.music.126.net/u9XGx1GMmtLD0oFXEqxhjQ==/109951167131488756.jpg?param=140y140","1.jpg");
TestCallable t2 = new TestCallable("http://p2.music.126.net/u9XGx1GMmtLD0oFXEqxhjQ==/109951167131488756.jpg?param=140y140","2.jpg");
TestCallable t3 = new TestCallable("http://p2.music.126.net/u9XGx1GMmtLD0oFXEqxhjQ==/109951167131488756.jpg?param=140y140","3.jpg");
//创建执行服务：
ExecutorService ser = Executors.newFixedThreadPool(1);
//提交执行：
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.shutdownNow();
}
}
class WebDownLoader1{
public void downloader(String url,String name) {
try {
FileUtils.copyURLToFile(new URL(url),new File(name));
} catch (Exception e) {
e.printStackTrace();
System.out.println("IO异常，downloader方法出现问题");
}
}
}
静态代理模式
总结：
-
真是对象和代理对象都要实现同一个接口
-
代理对象要代理真是角色
-
好处：
- 代理对象可以做很多真实对象做不了的事情
- 真实对象专注做自己的事情
-
public class StaticProxy { public static void main(String[] args) { You you = new You(); you.HappyMarry(); WeddingCompany weddingCompany = new WeddingCompany(new You()); weddingCompany.HappyMarry(); } } interface Marry{ void HappyMarry(); } //真是角色 你去结婚 class You implements Marry{ @Override public void HappyMarry() { System.out.println("周某人要结婚了，happy"); } } //代理角色 帮助你结婚 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("结婚之后，收尾款"); } }
Lambda 表达式
-
避免匿名内部类定义过多
-
其实质属于函数式编程的概念
-
new Thread(()-> System.out.println("我爱你")).start(); -
让代码变得简洁，去掉了一堆没有意义的代码，只留下核心的逻辑
-
Functional Interface（函数式接口） 是学习Java8 lambda 表达式的关键所在
-
函数式接口的定义：
- 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
- 对于函数式接口，我们可以通过lambda表达式来创建接口的对象
-
/* *推导lambda表达式 */ 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 TestLambda2 { public static void main(String[] args) { /*//1.lambda 表达示简化 ILove love = (int a) -> { System.out.println("I love you-->"+a); };*/ //简化1.参数类型 /*ILove love = (a) -> { System.out.println("I love you-->"+a); };*/ //简化2.简化括号 /*ILove love = a -> { System.out.println("I love you-->"+a); };*/ //简化3.去掉花括号 ILove love = a -> System.out.println("I love you-->"+a); love.love(2); /*总结： 能去掉花括号是因为只有一行代码 如果有多行代码 则不可简化 必须是函数式接口 也就是 接口中只有一个抽象方法(public abstract) 多个参数也可以去掉参数类型，若要去掉 则都要去掉，多个参数 也必须加上括号 */ } } interface ILove{ public abstract void love(int a); }
线程状态（五大状态）
停止线程
-
不推荐使用JDK提供的stop()、destroy ()方法。已废弃
-
推荐线程自己停止下来
-
建议使用一个标志位进行终止变量当flag = false，则终止线程运行。
-
//测试stop //建议线程正常停止-->利用次数，不建议死循环 //建议使用标志位-->设置一个标志位 //不要使用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.....Thread"+i++); } } //设置一个公开的方法停止线程，转换标志位 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 < 1000; i++) { System.out.println("main："+i); if (i==900){ testStop.stop(); System.out.println("线程该停止了"); } } } }
线程休眠
- sleep（时间）指定当前线程阻塞的毫秒数
- sleep 存在异常Interrupted Exception
- sleep时间达到后线程进入就绪状态
- sleep可以模拟网络延时，倒计时等
- 每一个对象都有一个锁，sleep不会释放锁`
线程礼让
- 礼让线程，让当前正在执行的线程暂停，但不阻塞
- 将线程从运行状态转为就绪状态
- 让CPU重新调度，礼让不一定成功！看CPU心情（进程出来重新竞争）
//测试礼让进程 礼让不一定成功，看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()+"线程停止执行");
}
}
多线程强制执行Join
-
Join合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞
-
可以想象成插队
-
//测试Join 想象为插队 public class TestJoin implements Runnable { @Override public void run() { try { Thread.sleep(1000); } catch (Exception e) { e.printStackTrace(); } for (int i = 0; i < 100; i++) { System.out.println("线程VIP来了"+i); } } public static void main(String[] args) throws Exception { //启动我们的线程 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); } } }
线程状态观测
Thread . State
-
New：
- 尚未启动的线程处于此状态。
-
RUNNABLE
- 在Java虚拟机中执行的线程处于此状态
-
BLOCKED
- 被阻塞等待监视器锁定的线程处于此状态
-
WAITING
- 正在等待另一个线程执行特定动作的线程处于此状态
-
TIMED_WAITING
- 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
-
TERMINATED
- 已退出的线程处于此状态
//观察测试线程的状态
public class TestState {
public static void main(String[] args) throws Exception {
Thread thread = new Thread(()->{
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (Exception 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);//Runnable
while (state!=Thread.State.TERMINATED){
Thread.sleep(100);
state = thread.getState();
System.out.println(state);
}
//thread.start();//死亡之后的线程不能再启动 线程只能启动一次
}
}
线程优先级
- Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度那个线程来执行。
- 线程的优先级用数字表示，范围从1>10
- Thread.MIN_PRIORITY = 1
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
- 使用以下方式改变或获取优先级
- getPriority() . setPriority(int xxx)
- 优先级的设定建议在start()调度签
- 优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度。
守护(daemon)线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕虚拟机不用等待守护线程执行完毕
- 如：后台记录操作日志,监控内存,垃圾回收等待..
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 < 365; i++) {
System.out.println("你一生开心的或者");
}
System.out.println("===goodbye!world===");
}
}
线程同步
多个线程操作同一个资源
并发：同一个对象被多个线程同时操作
-
处理多线程问题时,多个线程访问同一个对象﹐并且某些线程还想修改这个对象.这时候我们就需要线程同步﹒线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕，下一个线程再使用
-
队列和锁：想要确保线程安全，光有队列还不够，还需要加上锁，每个线程都有一把“锁”
-
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访叵冲突问题，为了保证数据在方法中被访问时的正确性﹐在访问时加入锁机制synchronized,当一个线程获得对象的排它锁,独占资源，其他线程必须等待，使用后释放锁即可.存在以下问题:
- 一个线程持有锁会导致其他所有需要此锁的线程挂起;
- 在多线程竞争下，加锁﹐释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
- 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置﹐引起性能问题.
三大不安全案例
-
不安全买票
-
public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"黄牛党").start(); new Thread(buyTicket,"辛苦的农民工").start(); new Thread(buyTicket,"军人").start(); } } class BuyTicket implements Runnable{ private int ticketNums = 10; boolean flag = true; @Override public void run() { while (flag){ try { buy(); } catch (Exception e) { e.printStackTrace(); } } } private void buy() throws Exception { //判断是否有票 if (ticketNums<=0){ flag = false; return; } //模拟延时 Thread.sleep(100); System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--); } /*线程不安全出现的情况 有重复买票的和 多买了票的 黄牛党拿到10 辛苦的农民工拿到9 军人拿到8 辛苦的农民工拿到7 黄牛党拿到6 军人拿到7 黄牛党拿到5 军人拿到3 辛苦的农民工拿到4 辛苦的农民工拿到2 军人拿到0 黄牛党拿到1*/ } -
//不安全取钱 //两个人去银行取钱，账户 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() { //判断有没有钱 if (account.money-drawingMoney<0){ System.out.println(Thread.currentThread().getName()+"钱不够"); return; } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //卡内余额 = 余额 - 你取的钱 account.money -= drawingMoney; //你手里的钱 = nowMoney += drawingMoney; System.out.println(account.name+"余额为："+account.money); //Thread.currentThread().getName() = this.getName() System.out.println(this.getName()+"手里的钱："+nowMoney); } /*结婚基金余额为：-50 结婚基金余额为：-50 你手里的钱：50 girlFriend手里的钱：100*/ } -
//线程不安全的集合 public class UnsafeList { public static void main(String[] args) throws Exception { List<String> list = new ArrayList<String>(); for (int i = 0; i < 10000; i++) { new Thread(()->{ list.add(Thread.currentThread().getName()); }).start(); } Thread.sleep(1000); System.out.println(list.size());//结果为：9999甚至更少 不安全 } }
同步方法
-
由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块
-
synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
-
缺陷：若将一个大的方法申明为synchronized将会影响效率
-
例如A代码（只读）B代码（修改） 而方法里面需要修改的内容才需要锁，同步方法锁的太多，浪费资源
-
同步块：synchronized(Obj){}
- Obj 称之为同步监听器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class
- 同步监视器的执行过程
- 第一个线程访问，锁定同步监视器，执行其中代码
- 第二个线程访问，发现同步监视器被锁定，无法访问
- 第一个线程访问完毕，解锁同步监视器
- 第二个线程访问，发现同步监视器没有锁，然后锁定并访问
- Obj 称之为同步监听器
-
public class SafeBuyTicket { public static void main(String[] args) { BuyTicket1 buyTicket = new BuyTicket1(); new Thread(buyTicket,"黄牛党").start(); new Thread(buyTicket,"辛苦的农民工").start(); new Thread(buyTicket,"军人").start(); } } class BuyTicket1 implements Runnable{ private int ticketNums = 10; boolean flag = true; @Override public void run() { while (flag){ try { //模拟延时 Thread.sleep(100); buy(); } catch (Exception e) { e.printStackTrace(); } } } //同步方法,锁的是this private synchronized void buy() { //判断是否有票 if (ticketNums<=0){ flag = false; return; } System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--); } /*军人拿到10 辛苦的农民工拿到9 黄牛党拿到8 辛苦的农民工拿到7 黄牛党拿到6 军人拿到5 黄牛党拿到4 军人拿到3 辛苦的农民工拿到2 辛苦的农民工拿到1*/ } -
synchronized默认锁的是this 有时候会需要使用同步块
-
同步块
-
//不安全取钱 //两个人去银行取钱，账户 public class SafeBank { public static void main(String[] args) { Account1 account1 = new Account1(100,"结婚基金"); Drawing1 you = new Drawing1(account1,50,"你"); Drawing1 girlFriend = new Drawing1(account1,100,"girlFriend"); you.start(); girlFriend.start(); } } class Account1{ int money1;//余额 String name1;//卡号 public Account1(int money1, String name1) { this.money1 = money1; this.name1 = name1; } } //银行 class Drawing1 extends Thread{ Account1 account1;//账户 //取了多少钱 int drawingMoney1; //现在手里有多少钱 int nowMoney1; public Drawing1(Account1 account1, int drawingMoney1, String name1){ super(name1); this.account1 = account1; this.drawingMoney1 = drawingMoney1; } //取钱 @Override public void run() { //锁的对象是变化的量 需要增删改 默认是this synchronized (account1) { //判断有没有钱 if (account1.money1 - drawingMoney1 < 0) { System.out.println(Thread.currentThread().getName() + "钱不够"); return; } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //卡内余额 = 余额 - 你取的钱 account1.money1 -= drawingMoney1; //你手里的钱 = nowMoney1 += drawingMoney1; System.out.println(account1.name1 + "余额为：" + account1.money1); //Thread.currentThread().getName() = this.getName() System.out.println(this.getName() + "手里的钱：" + nowMoney1); } } /*结婚基金余额为：50 你手里的钱：50 girlFriend钱不够*/ } -
CopyOnWriteArrayList JUC安全类型的结合
-
import java.util.concurrent.CopyOnWriteArrayList; //测试JUC安全类型的集合 public class TestJUC { public static void main(String[] args) throws InterruptedException { CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>(); for (int i = 0; i < 10000; i++) { new Thread(()->{ list.add(Thread.currentThread().getName()); }).start(); } Thread.sleep(3000); System.out.println(list.size()); } }
死锁
-
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。
-
//死锁 ：多个线程互相抱着对方需要的资源，然后形成僵持 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;//使用化妆品的人 Makeup(int choice,String girlName){ this.choice = choice; this.girlName = girlName; } @Override public void run() { //化妆 try { makeup(); } catch (Exception e) { e.printStackTrace(); } } //化妆 互相持有对方的锁 就是需要拿到对方的资源 private void makeup() throws Exception { if (choice==0){ synchronized (lipstick){//获得口红的锁 System.out.println(this.girlName+"获得口红的锁"); Thread.sleep(1000); /*synchronized (mirror){//一秒钟后获得镜子的锁 System.out.println(this.girlName+"获得镜子的锁"); }*/ } 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+"获得口红的锁"); }*/ } synchronized (lipstick){//一秒钟后获得口红的锁 System.out.println(this.girlName+"获得口红的锁"); } } } } -
产生死锁的四个必要条件：
- 互斥条件：一个资源每次只能被一个进程使用
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
- 不剥夺多条：进程已获得的资源，在未使用完之前，不能强行剥夺
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
- 上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生
Lock（锁）
-
从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
-
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
-
ReentrantLock类（可重入锁）实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
-
import java.util.concurrent.locks.ReentrantLock; //测试Lock锁 public class TestLock { public static void main(String[] args) { TestLock2 testLock2 = new TestLock2(); new Thread(testLock2).start(); new Thread(testLock2).start(); new Thread(testLock2).start(); } } class TestLock2 implements Runnable{ int ticketNums = 10; //定义lock 可重入锁 private final ReentrantLock lock = new ReentrantLock(); @Override public void run() { while (true){ try { lock.lock();//加锁 if (ticketNums>0){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(ticketNums--); }else { break; } }finally { //解锁 lock.unlock(); } } } }
synchronized 与 Lock 的对比
- Lock是显式锁（手动开启和关闭锁，别忘记关闭锁) synchronized是隐式锁，出了作用域自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
- 优先使用顺序:
- Lock >同步代码块（已经进入了方法体，分配了相应资源)>同步方法（在方法体之外)
线程协作（生产者消费者）
这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖,互为条件．
- 这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖,互为条件．
- 对于生产者，没有生产产品之前，要通知消费者等待．而生产了产品之后﹐又需要马上通知消费者消费
- 对于消费者﹐在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费.
- 在生产者消费者问题中,仅有synchronized是不够的
- synchronized可阻止并发更新同一个共享资源，实现了同步
- synchronized不能用来实现不同线程之间的消息传递(通信)
- Java提供了几个方法解决线程之间的通信问题
![]()
解决方式一：管程法
-
并发协作模型“生产者/消费者模式”--->管程法
-
生产者:负责生产数据的模块(可能是方法，对象，线程，进程);
-
消费者︰负责处理数据的模块(可能是方法，对象，线程，进程);
-
缓冲区:消费者不能直接使用生产者的数据，他们之间有个“缓冲区
-
生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据
-
//测试：生产者 消费者模型-->利用缓存区解决：管程法 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 = 0; 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 = 0; 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; } }
解决方式二：信号灯法
-
并发协作模型“生产者/消费者模式”--->信号灯法
-
//测试：生产者 消费者模型-->信号灯发，标志位解决 public class TestPC2 { 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++) { 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; } }
线程池
-
背景:经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
-
思路:提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
-
好处:
- 提高响应速度（减少了创建新线程的时间)
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建)
- 便于线程管理(…..)
- corePoolSize:核心池的大小
- maximumPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间后会终止
-
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class TestThreadPool { public static void main(String[] args) { //1.创建服务 创建线程池 newFixedThreadPool 参数为线程池大小 ExecutorService service = Executors.newFixedThreadPool(10); service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); //2.关闭连接 service.shutdown(); } } class MyThread implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()); } } -
import java.time.LocalDateTime; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class ThreadPool { public static void main(String[] args) { //无边界缓存线程池 ExecutorService cachedPool = Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) { cachedPool.submit(()->{ String name = Thread.currentThread().getName(); System.out.println(name); }); } //定长线程池 ExecutorService fixedPool = Executors.newFixedThreadPool(100); for (int i = 0; i < 10; i++) { fixedPool.submit(()->{ String name = Thread.currentThread().getName(); System.out.println(name); }); } //单核心处理线程 ExecutorService singlePool = Executors.newSingleThreadExecutor(); for (int i = 0; i < 10; i++) { singlePool.submit(()->{ String name = Thread.currentThread().getName(); System.out.println(name); }); } //定时任务线程池 ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(10); scheduledPool.scheduleAtFixedRate(()->{ String name = Thread.currentThread().getName(); System.out.println(name+"=="+LocalDateTime.now()); },5,2, TimeUnit.SECONDS); } }
浙公网安备 33010602011771号