学习视频链接：
https://www.bilibili.com/video/BV1V4411p7EF?spm_id_from=333.999.0.0进程 Process
程序：是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
进程：是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
线程 Thread
- 是独立的执行路径（真正执行任务的）
- 是CPU调度和执行的单位
- 通常在一个进程中可以包含若干个线程，一个进程中至少有一个线程
- 多线程的运行由调度器安排，调度器是与操作系统紧密相关的，先后顺序不能通过人为干预
- 默认线程： main（）主线程—用户线程 ，gc垃圾回收线程—守护线程
- 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
- 线程会带来额外的开销，如CPU调度时间，并发控制开销
- 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一时间点，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。
三种创建方式
Thread class -> 继承Thread类（重点）
- 自定义线程类继承Thread类
- 重写run()方法，编写线程执行体
- 创建线程对象，调用start（）方法启动线程（不是run()方法！！！）
注意：线程开启不一定立即执行，由cpu调度执行Runnable 接口 -> 实现Runnable接口（重点）
- 定义MyRunnable类实现Runnable接口
- 实现run()方法，编写线程执行体
- 创建线程对象，调用start（）方法启动线程（不是run()方法！！！）
继承Thread类 和 实现Runnable接口 对比
继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程：子类对象.start()
- 不建议使用：避免OOP单继承局限性
实现Runnable接口
- 实现接口RUnnable具有多线程能力
- 启动线程： new + Thread(传入目标对象).start()
- 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
Callable 接口 -> 实现Callable接口（了解）
- 实现Callable接口，需要返回值类型
- 实现call方法，需要抛出异常
- 创建目标对象
- 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
- 提交执行：Future<Boolean> result1 = ser.submit(t1);
- 获取结果：boolean r1 = result1.get()
- 关闭服务：ser.shutdownNow();
- Callable的好处： 1)可以定义返回值 2)可以抛出异常
练习代码：
package com.kuang.demo01; //创建线程方式一：继承Thread类，重写run()方法，调用start开启线程 //总结：注意，线程开启不一定立即执行，由cpu调度执行 public class TestThread1 extends Thread{ //重写run（）方法 @Override public void run() { //run方法执行体 for (int i = 0; i < 20; i++) { System.out.println("我在看代码--"+i); } } public static void main(String[] args) { //mian线程，主线程 //创建一个线程对象 TestThread1 testThread1 = new TestThread1(); //调用start（）方法开启线程 testThread1.start(); // testThread1.run(); for (int i = 0; i < 20; i++) { System.out.println("我在学习多线程"+i); } } }package com.kuang.demo01; //创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法 public class TestThread3 implements Runnable{ @Override public void run() { //run方法执行体 for (int i = 0; i < 20; i++) { System.out.println("我在看代码--"+i); } } public static void main(String[] args) { //创建runnable接口的实现类对象 TestThread3 t3 = new TestThread3(); //创建线程对象，通过线程对象来开启我们的线程，代理 // Thread thread = new Thread(); // thread.start(); //等价于下面创建线程对象的方法 new Thread(t3).start(); for (int i = 0; i < 20; i++) { System.out.println("我在学习多线程"+i); } } }package com.kuang.demo01; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; //练习Runnable，实现多线程同步下载图片 //3.实现Runnable接口 public class TestThread2 implements Runnable{ //4.创建构造方法 private String url;//网络图片地址 private String name;//保存的文件名 public TestThread2(String url,String name){ this.url = url; this.name = name; } //5.下载图片线程的执行体 @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("https://ke.gupaoedu.cn/img/java.3912e91c.png","java架构师.jpg"); TestThread2 t2 = new TestThread2("https://ke.gupaoedu.cn/img/ai.4aa795c4.png","人工智能AI.jpg"); TestThread2 t3 = new TestThread2("https://ke.gupaoedu.cn/img/bigdata.c3275a15.png","大数据工程师.jpg"); //方法一: // Thread thread = new Thread(t1); // // thread.start(); //等价于下面的写法二 new Thread(t1).start(); new Thread(t2).start(); new Thread(t3).start(); } } //1.下载器 class WebDownloader{ //2.下载方法 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方法出现问题"); } } } //--------------------------------------------------------------------------------- 练习Thread，实现多线程同步下载图片 3.继承Thread类 //public class TestThread2 extends Thread{ // // //4.创建构造方法 // private String url;//网络图片地址 // private String name;//保存的文件名 // // public TestThread2(String url,String name){ // this.url = url; // this.name = name; // } // // //5.下载图片线程的执行体 // @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("https://ke.gupaoedu.cn/img/java.3912e91c.png","java架构师.jpg"); // TestThread2 t2 = new TestThread2("https://ke.gupaoedu.cn/img/ai.4aa795c4.png","人工智能AI.jpg"); // TestThread2 t3 = new TestThread2("https://ke.gupaoedu.cn/img/bigdata.c3275a15.png","大数据工程师.jpg"); // // t1.start(); // t2.start(); // t3.start(); // } //} // 1.下载器 //class WebDownloader{ // //2.下载方法 // 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方法出现问题"); // } // } //}
Lambda表达式
用途：避免匿名内部类定义过多，
可以让代码看起来更简洁，
去掉无意义的代码，只留下核心的逻辑
本质：其实质属于函数式编程的概念
(params) -> expression [表达式] (params) -> statement [语句] (params) -> {statements}Functional Interface(函数式接口)
定义：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
例如：Runnable接口，只有一个run（）方法
对于函数式接口，可以通过lambda表达式来创建该接口的对象
- lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹
- 前提是接口为函数式接口
- 多个参数也可以去掉参数烈性，要去掉就都去掉，必须要加上括号
推导代码：
package com.kuang.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 = 因为函数式接口只有唯一一个抽象类，所以只要调用该函数式接口， 就必定使用该函数式接口中的唯一抽象方法，可以使用->简化 new Ilike() { @Override public void lambda () { System.out.println("I like lambda4"); } }; */ 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"); } } --------------------------------------------------------------------------------------- package com.kuang.lambda; public class TestLambda2 { public static void main(String[] args) { Ilove love = null; //1.lambda表示简化 // Ilove love = (int a)-> { // System.out.println("i love you-->" + a); // }; //简化1：参数类型 // love = (a)-> { // System.out.println("i love you-->" + a); // }; //简化2：简化括号 // love = a -> { // System.out.println("i love you-->" + a); // }; //简化3：去掉花括号 love = (a,b) -> System.out.println("i love you-->" + a); love.love(520,521); //总结： //lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹 //前提是接口为函数式接口 //多个参数也可以去掉参数烈性，要去掉就都去掉，必须要加上括号 } interface Ilove { void love(int a,int b) ; } }
静态代理
- 真实对象和代理对象都要实现同一个接口
- 代理对象要代理真实角色
辅助理解代码：
//好处： //代理对象可以做很多真实对象做不了的事情 //真实对象专注做自己的事情 public class StaticProxy { public static void main(String[] args) { You you = new You(); new Thread(()-> System.out.println("我爱你")).start(); new WeddingCompany(you).HappyMarry(); // WeddingCompany weddingCompany = new WeddingCompany(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("结婚之后，收尾款"); } }
线程状态
1.创建状态
2.就绪状态
3.运行状态
4.阻塞状态
5.死亡状态
一旦进入死亡状态，就不能再次启动
停止线程：
- 建议使用一个标志位进行终止变量 当flag = false，则终止线程运行。
- 不推荐使用JDK提供的stop()、destroy()方法
线程休眠 — sleep ：
- sleep（时间）指定当前线程阻塞的毫秒数； 1000毫秒 = 1 秒
- sleep存在异常InterruptedException；
- sleep时间达到后线程进入就绪状态；
- sleep可以模拟网络延时，倒计时等。
- 每一个对象都有一个锁，sleep不会释放锁
线程礼让 — yield ：
- 礼让线程，让当前正在执行的线程暂停，但不阻塞
- 将线程从运行状态转为就绪状态
- 让cpu重新调度，礼让不一定成功！看cpu心情
线程强制执行 — join ：
- join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
- 可以想象成插队
线程优先级 Priority
- 线程的优先级用数字表示，范围从1~10 数字越大，优先级越高
优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了。
这都是看CPU的调度
- 使用一下方式改变或获取优先级 ： getPriority() setPriority(int XXX)
优先级的设定建议在start()调度前
守护线程 daemon
- 线程分为 用户线程 和 守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 例如：后台记录操作日志，监控内存，垃圾回收等待
线程同步 synchronized
多个线程操作同一个资源，存在安全性问题
解决安全方法 ： 队列 + 锁
优势：处理安全问题
不足：引起性能问题
例如：卖票问题，银行取钱问题，ArrayList问题
package com.kuang.syn; import java.sql.SQLOutput; //不安全的卖票 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){ try { buy(); } catch (InterruptedException e) { e.printStackTrace(); } } } //判断是否有票 private void buy() throws InterruptedException { if (ticketNums <= 0){ flag = false; return; } //模拟延时 Thread.sleep(100); //买票 System.out.println(Thread.currentThread().getName() + "拿到了" + ticketNums--); } } --------------------------------------------------------------------------------------- package com.kuang.syn; //不安全的取钱 //两个人去银行取钱，账户 public class UnsafeBank { public static void main(String[] args) { //账户 Accout accout = new Accout(100,"结婚基金"); Drawing you = new Drawing(accout,50,"你"); Drawing girlFriend = new Drawing(accout,100,"girlFriend"); you.start(); girlFriend.start(); } } //账户 class Accout{ int money;//余额 String name;//卡名 public Accout(int money, String name) { this.money = money; this.name = name; } } //银行:模拟取款 class Drawing extends Thread{ Accout accout;//账户 //取了多少钱 int drawingMoney; //现在手上有多少钱 int nowMoney; public Drawing(Accout accout,int drawingMoney,String name){ super(name); this.accout = accout; this.drawingMoney =drawingMoney; } //取钱 @Override public void run() { //判断有没有钱 if (accout.money - nowMoney < 0){ System.out.println(Thread.currentThread().getName() + "钱不够，取不了"); return; } //sleep可以放大问题的发生性 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } //卡内余额 = 余额 - 你取的钱 accout.money = accout.money - drawingMoney; //你手里的钱 nowMoney = nowMoney + drawingMoney; System.out.println(accout.name + "余额为：" + accout.money); //Thread.currentThread().getName() = this.getName() System.out.println(this.getName() + "手里的钱：" + nowMoney); } } --------------------------------------------------------------------------------------- package com.kuang.syn; import java.util.ArrayList; import java.util.List; //线程不安全的结合 public class UnsafeList { public static void main(String[] args) { List<String> list = new ArrayList<String>(); for (int i = 0; i < 10000; i++) { new Thread(()->{ list.add(Thread.currentThread().getName()); }).start(); } try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); } }
同步方法 和 同步块
同步方法 ：
public synchronized void method(int args){}同步方法弊端：方法里面需要修改的内容才需要锁，锁的太多，浪费资源
同步块：
synchronized(Obj){} //Obj:同步监视器！此方法待继续学习，视频未理解
死锁
产生的四个必要条件：
- 互斥条件：一个资源每次只能被一个进程使用
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
- 不剥夺条件：进程已获得的资源，在未使用完之前，不能被强行剥夺
- 循环等待条件：若干进程之前形成一种头尾相接的循环等待资源关系
Lock锁
从JDK5.0开始 Java提供了线程同步机制
java.util.concurrent.locks Lock接口是控制多个线程对共享资源进行访问的工具
ReentrantLock 类实现了Lock，可以显式加锁，释放锁
ReentrantLock 可重入锁
练习代码：
package com.kuang.gaoji; import java.util.concurrent.locks.ReentrantLock; public class TestLock { public static void main(String[] args) { TestLock2 t1 = new TestLock2(); new Thread(t1,"a").start(); new Thread(t1,"b").start(); new Thread(t1,"c").start(); } } class TestLock2 implements Runnable{ int ticketnum =1000; //定义lock锁 private final ReentrantLock lock = new ReentrantLock(); @Override public void run() { while (true){ try{ lock.lock();//加锁 if (ticketnum>0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "获得了第" + ticketnum--); }else{ break; } }finally { //解锁 lock.unlock(); } } } }
synchronized 与 Lock 的对比
- 显式方式
Lock是显式锁（手动开启和关闭锁，别忘记关闭锁）
synchronized是隐式锁，出了作用域自动释放
- 类型
Lock只有代码块锁
synchronized有代码块锁和方法锁
- 优先使用顺序
Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
生产者消费者问题
线程通信
方法名 作用 wait() 表示线程一直等待，知道其他线程通知，与sleep不同，会释放锁 wait(long timeout) 指定等待的毫秒数 notify() 唤醒一个处于等待状态的线程 notifyAll() 唤醒同一个对象上所有调用wait()方法的线程，优先级别搞定线程优先调度 注意：以上方法均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IIIegalMonitorStateException
管程法
package com.kuang.gaoji; //测试：生产者消费者模型-->利用缓冲区解决：管程法 //生产者，消费者，产品，缓冲区 public class TestPC { public static void main(String[] args) { Syncontainer container = new Syncontainer(); new Producer(container).start(); new Consumer(container).start(); } } //生产者 producer 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 + "只鸡"); //生产后休眠一段时间 try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } } } } //消费者 consumer 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 + "只鸡"); //消费后休眠一段时间，防止出现超前消费问题 try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } } } } //产品 class Chicken{ int id;//产品编号 public Chicken(int id){ this.id = id; } } //缓冲区 syncontainer class Syncontainer{ //需要一个容器大小 Chicken[] chickens = new Chicken[10]; //容器计数器 int count = 0; //生产者放入产品 如果有产品，提醒消费者消费；如果没有产品，提醒生产者生产 public synchronized void push(Chicken chicken){ //如果容器满了，就需要等待消费者消费 while (count == chickens.length){ //通知消费者消费，生产等待 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果没有满，就需要丢入产品 chickens[count] = chicken; count++; //可以通知消费者消费 this.notifyAll(); } //消费者消费产品 如果有产品，正常消费；如果没有产品，等待生产者唤醒消费 public synchronized Chicken pop(){ //判断能否消费 while(count == 0){ //等待生产者生产，消费者等待 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果可以消费 count--; Chicken chicken = chickens[count]; //吃完了，通知生产者生产 this.notifyAll(); return chicken; } }信号灯法
package com.kuang.gaoji; //测试：生产者消费者模型-->信号灯法 判断标志位 作家和读者 写小说和看小说 public class TestPC2 { public static void main(String[] args) { Book book =new Book(); new Writer(book).start(); new Reader(book).start(); } } //生产者--作家 class Writer extends Thread{ Book book; public Writer(Book book){ this.book = book; } @Override public void run() { for (int i = 0; i < 10; i++) { if (i % 2 == 0) { this.book.write("献给阿尔加侬的花束"); }else { this.book.write("二十四个比利"); } } } } //消费者--读者 class Reader extends Thread{ Book book; public Reader(Book book){ this.book = book; } @Override public void run() { for (int i = 0; i < 10; i++) { this.book.read(); } } } //产品--小说 class Book { String Books;//写的小说 Boolean flag = true; //作家写小说,读者等待 //读者看小说,作家等待 // 作家写小说 public synchronized void write(String Books){ if (!flag){ try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("作家更新了：----" + Books + "----"); //通知读者看小说 this.notifyAll(); this.Books = Books; this.flag = !this.flag; } //读者看小说 public synchronized void read(){ if (flag){//true 等待作者写小说 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("读者看了更新后的：" + Books); //通知作者写小说 this.notifyAll(); this.flag = !this.flag; } }
线程池
- 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
- 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
- 好处：
- 提高响应速度（减少创建新线程的时间）
- 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
- 便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多长时间后会终止
- JDK5.0起提供了线程池相关API：ExecutorService 和 Executors
- ExcutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
- <T>Future<T> submit(Callable<T>task)：执行任务，有返回值，一般用来执行Callable
- void shutdown()：关闭连接池
- Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
package com.kuang.gaoji; 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); //执行 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()); } }
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
