13 多线程
并发与并行
并发：单个cpu在多个任务之间来回切换
并行：多核多线程（所以速度快）
进程的概念
线程调度
分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。 抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（程随机性），Java使用的为抢占式调度。
主线程
单线程
package 多线程.线程实现方式;
/*
主线程：执行主方法（main）方法的线程
单线程程序：java程序只有一个线程
执行从main方法开始，从上到下依次执行
*/
public class Demo01 {
public static void main(String[] args) {
Person p1 = new Person("小强");
p1.run();
System.out.println(0/0);//这个程序会报错
//hread "main" java.lang.
//单线程的劣势就是这儿报错，再往下不执行
Person p2 = new Person("旺财");
p2.run();
}
}
多线程
package 多线程.线程实现方式;
/*
创建多线程的第一种方式
实现步骤：
1.创建一个Thread类的子类
2.在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
3.创建Thread类的子类对象
4.调用Thread类中的方法start方法，开启新的线程，执行run方法
void start（）使该线程开始执行；Java虚拟机调用该线程的run方法。
结果是两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程，执行其run方法）。
多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
java程序属于抢占式调度，那个线程的优先级高，那个线程优先执行；同一个优先级，随机选择一个执行
*/
public class Demo02 {
public static void main(String[] args) {
//3.创建Thread类的子类对象
MyThread mt = new MyThread();
//4.调用Thread类中的方法start方法，开启新的线程，执行run方法
mt.start();
for (int i = 0; i < 20; i++) {
System.out.println("main"+i);
}
}
}
package 多线程.线程实现方式;
//创建一个Thread子类
public class MyThread extends Thread{
//2.在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
多线程原理
Thread类获取线程名称
package 多线程.线程实现方式;
/*
获取线程的名称：
1.使用Thread类中的方法getName（）
String getName（）返回该线程的名称。
2.可以先获取到当前正在执行的线程，使用线程中的方法getName（）获取线程的名称
static Thread current Thread（）返回对当前正在执行的线程对象的引用。
*/
//定义一个Thread子类
public class MyThread extends Thread{
//2.在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
package 多线程.线程实现方式;
/*
线程的名称：
主线程：main
新线程：Thread-0，Thread-1，-------
*/
public class Demo02 {
public static void main(String[] args) {
//创建Thread类的子类对象
MyThread mt = new MyThread();
//调用Thread类中的方法start方法，开启新的线程，执行run方法
mt.start();
new MyThread().start();
//链式编程
System.out.println(Thread.currentThread().getName());
}
}
Thread类设置线程名称
package 多线程.线程实现方式;
/*
设置线程的名称：（了解）
1.使用Thread类中的方法setName（名字）
void setName（String name）改变线程名称，使之与参数name相同。
2.创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，
把线程名称传递给父类，让父类（Thread）给子线程起一个名字
Thread（String name）分配新的Thread 对象。
*/
public class MyThread extends Thread{
package 多线程.线程实现方式;
public class Demo02 {
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.setName("小王");
mt.start();//本来是 01
}
}
Thread类 sleep
package 多线程.线程实现方式;
public class Demo02<start> {
public static void main(String[] args) {
//模拟秒表
for (int i = 0; i <= 60; i++) {
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
创建多线程的第二种方式
package 多线程.线程实现方式;
//创建一个runnable接口的实现类
public class RunnableImpl implements Runnable {
package 多线程.线程实现方式;
/*
创建多线程程序的第二种方式：实现Runnable接口
java.Lang.RunnabLe Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run的无参数方法。
java.Lang.Thread类的构造方法
Thread（Runnable target）分配新的Thread对象。
Thread（Runnable target，String name）分配新的Thread对象。
实现步骤：
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法，设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5.调用Thread类中的start方法，开启新的线程执行run方法
*/
public class Demo03 {
public static void main(String[] args) {
//3创建一个Runnable接口的实现类对象
RunnableImpl run = new RunnableImpl();
//4.创建Thread类对象
Thread t = new Thread(run);
// 5.调用Thread类中的start方法，
t.start();
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
Thread和Runnable接口的区别
实现Runnable接口创建多线程程序的好处： 1.避免了单继承的局限性 一个类只能继承一个类（一个人只能有一个亲爹），类继承了Thread类就不能继承其他的类实现了Runnable接口，还可以继承其他的类，实现其他的接口 2.增强了程序的扩展性，降低了程序的耦合性（解耦） 实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦） 实现类中，重写了run方法：用来设置线程任务创建Thread类对象，调用start方法：用来开启新线程
匿名内部类的方式创建线程
package 多线程.线程实现方式;
/*
匿名内部类方式实现线程的创建
匿名：没有名字
内部类：写在其他类内部的类
匿名内部类作用：简化代码
把子类继承父类，重写父类的方法，创建子类对象合一步完成
把实现类实现类接口，重写接口中的方法，创建实现类对象合成一步完成
匿名内部类的最终产物：子类/实现类对象，而这个类没有名字
格式：new父类/接口（）{
重复父类/接口中的方法
}；
*/
public class Demo04 {
public static void main(String[] args) {
//线程的父类是Thread
//new MyThread().start();
new Thread() {
//重写run方法，设置线程任务
02 线程同步机制
线程安全问题
同步代码块（第一种解决方法）
package 多线程.线程安全问题;
/*
卖票案例出现了线程安全问题
卖出了不存在的票和重复的票
解决线程安全问题的第二种方案：使用同步方法
使用步骤：
1.把访问了共享数据的代码抽取出来，放到一个方法中
2.在方法上添加synchronized修饰符
格式：定义方法的格式
修饰符synchronized返回值类型方法名（参数列表）{
可能会出现线程安全问题的代码（访问了共享数据的代码）
}
*/
public class RunnableImpl implements Runnable{
//定义一个多个线程共享的票源
private int ticket = 100;
//创建一个锁对象
Object object = new Object();
//设置线程任务
package 多线程.线程安全问题;
/*
模拟卖票案例
创建三个线程，同时开启，对共享的票进行出售
*/
public class Demo01 {
public static void main(String[] args) {
//创建runnable接口的实现类对象
Runnable run = new RunnableImpl();
//创建Thread类对象，构造方法中传递Runnable接口的实现对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
t0.start();
t1.start();
t2.start();
}
}
同步技术的原理
同步方法（第二中解决方案）
package 多线程.线程安全问题;
/*
卖票案例出现了线程安全问题
卖出了不存在的票和重复的票
解决线程安全问题的第二种方案：使用同步方法
使用步骤：
1.把访问了共享数据的代码抽取出来，放到一个方法中
2.在方法上添加synchronized修饰符
格式：定义方法的格式
修饰符synchronized返回值类型方法名（参数列表）{
可能会出现线程安全问题的代码（访问了共享数据的代码）
}
*/
public class RunnableImpl implements Runnable{
//定义一个多个线程共享的票源
private int ticket = 100;
//设置线程任务
package 多线程.线程安全问题;
/*
模拟卖票案例
创建三个线程，同时开启，对共享的票进行出售
*/
public class Demo01 {
public static void main(String[] args) {
//创建runnable接口的实现类对象
Runnable run = new RunnableImpl();
System.out.println("run:"+run);
//创建Thread类对象，构造方法中传递Runnable接口的实现对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
t0.start();
t1.start();
t2.start();
}
}
静态同步方法
package 多线程.线程安全问题;
/*
卖票案例出现了线程安全问题
卖出了不存在的票和重复的票
解决线程安全问题的第二种方案：使用同步方法
使用步骤：
1.把访问了共享数据的代码抽取出来，放到一个方法中
2.在方法上添加synchronized修饰符
格式：定义方法的格式
修饰符synchronized返回值类型方法名（参数列表）{
可能会出现线程安全问题的代码（访问了共享数据的代码）
}
*/
public class RunnableImpl implements Runnable{
//定义一个多个线程共享的票源
private static int ticket = 100;
//设置线程任务
package 多线程.线程安全问题;
/*
模拟卖票案例
创建三个线程，同时开启，对共享的票进行出售
*/
public class Demo01 {
public static void main(String[] args) {
//创建runnable接口的实现类对象
Runnable run = new RunnableImpl();
System.out.println("run:"+run);
//创建Thread类对象，构造方法中传递Runnable接口的实现对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
t0.start();
t1.start();
t2.start();
}
}
Lock锁（第三种解决方法）
package 多线程.线程安全问题;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
卖票案例出现了线程安全问题
卖出了不存在的票和重复的票
解决线程安全问题的第三种方案：使用Lock锁
java.util.concurrent.locks.Lock接口
Lock 实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。
Lock接口中的方法：
void lock（）获取锁。
void unLock（）释放锁。
java.util.concurrent.locks.ReentrantLock implements Lock接口
使用步骤：
1.在成员位置创建一个ReentrantLock对象
2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
*/
public class RunnableImpl implements Runnable{
//定义一个多个线程共享的票源
private static int ticket = 100;
// 1.在成员位置创建一个ReentrantLock对象
Lock l = new ReentrantLock();
//设置线程任务
package 多线程.线程安全问题;
/*
模拟卖票案例
创建三个线程，同时开启，对共享的票进行出售
*/
public class Demo01 {
public static void main(String[] args) {
//创建runnable接口的实现类对象
Runnable run = new RunnableImpl();
//创建Thread类对象，构造方法中传递Runnable接口的实现对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
t0.start();
t1.start();
t2.start();
}
}
lock锁补充知识，，无论程序是否出错，都会把锁释放，从而提高效率
package 多线程.线程安全问题;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
卖票案例出现了线程安全问题
卖出了不存在的票和重复的票
解决线程安全问题的第三种方案：使用Lock锁
java.util.concurrent.locks.Lock接口
Lock 实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。
Lock接口中的方法：
void lock（）获取锁。
void unLock（）释放锁。
java.util.concurrent.locks.ReentrantLock implements Lock接口
使用步骤：
1.在成员位置创建一个ReentrantLock对象
2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
*/
public class RunnableImpl implements Runnable{
//定义一个多个线程共享的票源
private static int ticket = 100;
// 1.在成员位置创建一个ReentrantLock对象
Lock l = new ReentrantLock();
//设置线程任务
package 多线程.线程安全问题;
/*
模拟卖票案例
创建三个线程，同时开启，对共享的票进行出售
*/
public class Demo01 {
public static void main(String[] args) {
//创建runnable接口的实现类对象
Runnable run = new RunnableImpl();
//创建Thread类对象，构造方法中传递Runnable接口的实现对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
t0.start();
t1.start();
t2.start();
}
}
03 等待唤醒机制
线程状态
等待唤醒案例
package 多线程.等待唤醒机制;
/*
等待唤醒案例：线程之间的通信
创建一个顾客线程（消费者）：告知老板要的包子的种类和数量，调用wait方法，放弃cpu的执行，进入到WAITING状态（无限等待）
创建一个老板线程（生产者）：花了5秒做包子，做好包子之后，调用notify方法，唤醒顾客吃包子
注意：
顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
同步使用的锁对象必须保证唯一
只有锁对象才能调用wait和notify方法
Obejct类中的方法
void wait（）
在其他线程调用此对象的notify（）方法或notifyAll（）方法前，导致当前线程等待。
void notify（）
唤醒在此对象监视器上等待的单个线程。
会继续执行wait方法之后的代码
*/
public class Demo01 {
public static void main(String[] args) {
//创建锁对象，保证唯一
Object obj = new Object();
//创建一个顾客线程（消费者）
new Thread(){
wait带参方法和notify
package 多线程.等待唤醒机制;
/*
进入到Timewaiting（计时等待）有两种方式
1.使用sleep（Long m）方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态
2.使用wait（Long m）方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，，线程睡醒进入到Runnable/Blocked状态
唤醒的方法 ：void notify（）唤醒在此对象监视器上等待的单个线程。
void notifyALL（）换醒在此对象监视器上等待的所有线程。
*/
public class Demo02 {
public static void main(String[] args) {
//创建锁对象，保证唯一
Object obj = new Object();
//创建一个顾客线程（消费者）
new Thread(){
线程间通信（等待唤醒机制）![]()
等待唤醒机制需求分析
等待唤醒机制代码实现（包子类&包）
package 多线程.等待唤醒机制;
/*
资源类：包子类
设置包子的属性
皮
馅
包子的状态： 有 true 没有 false
*/
public class BaoZi {
//皮
String pi;
//馅
String xian;
//包子的状态：有 true 没有 false, 设置初始值为false
boolean flag = false;
}
package 多线程.等待唤醒机制;
/*
生产者（包子铺）类：是一个线程类，可以继承Thread
设置线程任务（run）：生产包子
对包子的状态进行判断
true：有包子
包子铺调用wait方法进入等待状态
false：没有包子
包子铺生产包子
增加一些趣味性：交替生产两种包子
有两种状态（i%2==0）
包子铺生产好了包子
修改包子的状态为true有
唤醒吃货线程，让吃货线程吃包子
注意：
包子铺线程和包子线程关系-->通信（互斥）
必须同时同步技术保证两个线程只能有一个在执行
锁对象必须保证唯一，可以使用包子对象作为锁对象
包子铺类和吃货的类就需要把包子对象作为参数传递进来
1.需要在成员位置创建一个包子变量
2.使用带参数构造方法，为这个包子变量赋值
*/
public class BaoZiPu extends Thread{
// 1.需要在成员位置创建一个包子变量
private BaoZi bz;
// 2.使用带参数构造方法，为这个包子变量赋值
public BaoZiPu(BaoZi bz) {
this.bz = bz;
}
//设计线程任务（run）；生产包子
package 多线程.等待唤醒机制;
/*
消费者（吃货）类：是一个线程类，可以继承Thread
设置线程任务（run）：吃包子
对包子的状态进行判断
false：没有包子
吃货调用wait方法进入等待状态
true：有包子
吃货吃包子
吃货吃完包子
修改包子的状态为false没有
吃货唤醒包子铺线程，生产包子
*/
public class ChiHuo extends Thread{
// 1.需要在成员位置创建一个包子变量
private BaoZi bz;
// 2.使用带参数构造方法，为这个包子变量赋值
public ChiHuo(BaoZi bz) {
this.bz = bz;
}
//设置线程任务：吃包子
package 多线程.等待唤醒机制;
/*
测试类：
包含main方法，程序执行的入口，启动程序
创建包子对象；
创建包子铺线程，开启，生产包子；
创建吃货线程，开启，吃包子；
*/
public class Demo03 {
public static void main(String[] args) {
//创建包子对象
BaoZi bz = new BaoZi();
//创建包子铺线程，开启，生产包子
new BaoZiPu(bz).start();
//创建吃货线程
new ChiHuo(bz).start();
}
}
04线程池
线程池的代码实现
package 多线程.线程池;
//2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
public class RunnableImpl implements Runnable {
package 多线程.线程池;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*
线程池：JDK1.5之后提供的
java.util.concurrent.Executors：线程池的工厂类，用来生成线程池
Executors类中的静态方法：
static ExecutorService newFixedThreadPool（int nThreads）创建一个可重用固定线程数的线程池
参数：int nThreads：创建线程池中包含的线程数量
返回值：Executorservice接口，返回的是Executorservice接口的实现类对象，我们可以使用Executorservice接口接收（面向接口编程）
java.util.concurrent.Executorservice：线程池接口
用来从线程池中获取线程，调用start方法，执行线程任务
submit（Runnable task）提交-Runnable 任务用于执行
关闭/销毁线程池的方法
void shutdown（）
线程池的使用步骤：
1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
3.调用ExecutorService中的方法submit，传递线程任务（实现类），开启线程，执行run方法
4.调用ExecutorService中的方法shutdown销毁线程池（不建议执行）
*/
public class Demo01 {
public static void main(String[] args) {
// 1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
ExecutorService es = Executors.newFixedThreadPool(2);
// 3.调用ExecutorService中的方法submit，传递线程任务（实现类），开启线程，执行run方法
es.submit(new RunnableImpl());
// 线程池会一直开启，使用完了线程，会自动归还线程给线程池，线程可以继续使用
es.submit(new RunnableImpl());
es.submit(new RunnableImpl());
// 4.调用ExecutorService中的方法shutdown销毁线程池（不建议执行）
es.shutdown();
// es.submit(new RunnableImpl()); 上一行代码表示线程池都没有了，于是这行代码会抛出异常
}
}
06 Lambda表达式
函数式编程思想
面向对象的思想：做一件事情，找一个能解决这个事情的对象，调用对象的方法，完成事情. 函数式编程思想：只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程
冗余的Runnable代码
package 多线程.Lambda;
public class Demo01 {
public static void main(String[] args) {
//创建RUnnable接口的实现类对象
Runnable run = new RunnableImpl();
//创建Tread类对象，构建方法中传递Runnable接口的实现类
Thread t = new Thread(run);
//调用start方法开启新线程，执行run方法
t.start();
//简化代码，使用匿名内部类，实现多线程程序
Runnable r = new Runnable() {
package 多线程.Lambda;
public class Demo01 {
public static void main(String[] args) {
//创建RUnnable接口的实现类对象
Runnable run = new RunnableImpl();
//创建Tread类对象，构建方法中传递Runnable接口的实现类
Thread t = new Thread(run);
//调用start方法开启新线程，执行run方法
t.start();
//简化代码，使用匿名内部类，实现多线程程序
Runnable r = new Runnable() {
体验Lambda的更优写法
package 多线程.Lambda;
/*
*/
public class Demo02 {
public static void main(String[] args) {
//使用匿名类的方式实现多线程
new Thread(new Runnable() {
lambda标准写法
Lambda表达式的标准格式：
由三部分组成：
a.一些参数
b.一个箭头
c.一段代码
格式： （参数列表）->（一些重写方法的代码）；
解释说明格式： （）：接口中抽象方法的参数列表，没有参数，就空着；有参数就写出参数，多个参数使用逗号分隔 ->：传递的意思，把参数传递给方法体子 （）：重写接口的抽象方法
lambda表达式（无参数无返回值）
package 多线程.Lambda;
/*
需求：给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值。
使用Lambda的标准格式调用invokeCook方法，打印输出"吃饭啦！"字样
*/
public class Demo01Cook {
public static void main(String[] args) {
//调用invokecook方法，参数是Cook接口，传递Cook接口的匿名内部类对象
invokeCook(new Cook() {
lambda表达式（无参数无返回值）
package 多线程.Lambda;
import java.util.Arrays;
import java.util.Comparator;
/*
Lambda表达式有参数有返回值的练习
需求：
使用数组存储多个Person对象
对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序
*/
public class Demo01Arrays {
public static void main(String[] args) {
//使用数组存储多个Person对象
Person[] arr = {
new Person("柳岩",38),
new Person("迪丽热巴",18),
new Person("古力娜扎",19),
};
//对数组中的Person对象使用Array的sort方法通过年龄进行升序(前边-后边）排序
// Arrays.sort(arr, new Comparator<Person>() {
// @Override
// public int compare(Person o1, Person o2) {
// return o1.getAge()- o2.getAge();
// }
// });
//使用lambda简化匿名内部类
Arrays.sort(arr,(Person o1, Person o2) -> {
return o1.getAge() - o2.getAge();
});
//遍历数组
for (Person p : arr) {
System.out.println(p);
}
}
}
lambda省略格式
//使用lambda表达式实现多线程
//简单写法
new Thread(() -> System.out.println(Thread.currentThread().getName()+"新线程创建了")).start();
//复杂写法
new Thread(() ->{
System.out.println(Thread.currentThread().getName()+"新线程创建了");
}
).start();
new Thread(() -> System.out.println(Thread.currentThread().getName()+"新线程创建了")).start();
}
package 多线程.Lambda;
import java.util.ArrayList;
/*
lambda表达式；是可推到，可以省略的
凡是根据上下文推到出来的内容，都可以省略数学
可以省略的内容：
1.(参数列表）:括号中参数列表的数据类型，可以省略不写
2.（参数列表）：括号中的参数如果只有一个，那么类型和（）都可以省略
3.（一些代码）：如果{}中的代码只有一行，无论是否有返回值，都可以省略（{}，return，分号）
注意：要省略 （{}，return，分号） 必须同时省略，
*/
public class Demo01ArrayList {
public static void main(String[] args) {
ArrayList<String> list02 = new ArrayList<>();
}
}
Lambda的使用前提:
Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：
1.使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法*。 无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时才可以使用Lambda，
2.使用Lambda必须具有上下文推断。 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
备注：有且仅有一个抽象方法的接口，称为“函数式接口”。
浙公网安备 33010602011771号