多线程
一、相关概念
1.程序、进程、线程三者的区别？
程序：我们每天写的代码（代码是死的）
//比如：没有运行的飞秋，它就是一个程序
进程：运行起来的代码
//比如：运行起来的飞秋，它就是一个进程
线程：是"进程"中的单个顺序控制流，是一条执行路径
//我们使用qq可以一边聊天、一边下载 聊天时一个线程、下载也是一个线程
2.进程和线程之间的关系
（1）线程是依赖于进程的 //我想和乔梦佳同学聊天，我就必须先起启动qq这个进程
（2）一个进程中可以有多个线程 //电脑管家这个进程，里面包含病毒查杀、垃圾清理等多个线程
进程是线程的一个集合（容器），真正干活的是线程
3.小问题
（1）电脑管家中病毒查杀、垃圾清理、电脑加速多个线程，请问他们是同时执行的吗？
不是，在同一个时间点CPU只能做一件事。之所以你看起来像是在同时做多件事，是因为CPU在做着高速的切换
（2）电脑管家中病毒查杀、垃圾清理,他们之间的执行有没有顺序？
没有顺序，抢占式调度模型（谁抢到谁执行）
4.多线程的好处
我们可以一边玩游戏，一边听音乐。无形中提搞了CPU的使用效率。提高了CPU的执行效率
二、实现多线程的第一种方式-----继承Thread类 //☆☆☆☆☆
1.步骤
（1）定义一个类MyThread继承Thread类
（2）在MyThread类中重写run()方法
（3）创建MyThread类的对象
（4）启动线程
代码实现：
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
}
}
------------------------------------------------------
public class Demo1 {
public static void main(String[] args) {
MyThread m1 = new MyThread();
MyThread m2 = new MyThread();
m1.start();
m2.start();
}
}
2.在多线程中run方法和start方法的区别？ //面试题
void run() ：里面的内容是线程需要执行的逻辑，直接调用相当于普通方法
void start()： 使此线程开始执行，Java虚拟机（进程）会调用run方法()
//Java的运行原理
编写代码----编译（javac）----运行（java）
当我们执行java命令的时候，启动一个JVM（Java虚拟机），这里的JVM其实就是一个进程，然后去创建一个名为main的线程，调用该线程里面的main方法
3.设置和获取线程的名称
（1）如果我不给线程设置名称，有没有名称
有
Thread-x x从0开始的
（2）线程设置名称的方式
*使用setName(String name)方法
//一定要在创建线程对象之后再使用该方法
MyThread m1 = new MyThread();
m1.setName("飞机");
MyThread m2 = new MyThread();
m2.setName("火车");
*使用构造方法的方式
//需要在线程类MyThread中添加一个带String类型的构造方法
MyThread m1 = new MyThread("飞机");
MyThread m2 = new MyThread("火车");
（3）获取线程名称的方式
*使用getName()方法获取。
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(this.getName()+":"+i); //在线程类中的run方法里来获取线程名称
}
}
*使用Thread.currentThread().getName()方法
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
4.线程的优先级 //了解
final int getPriority() 返回此线程的优先级
final void setPriority(int newPriority)更改此线程的优先级 线程默认优先级是5；线程优先级的范围是：1-10
（1）线程优先级的范围
1-10
（2）线程的默认优先级
5
（3）线程的优先级越高，代表获取到CPU的执行权的概率越高，并不能保证一定能抢到
5.线程的控制 //了解
（1）static void sleep(long millis) 使当前正在执行的线程停留（暂停执行）指定的毫秒数
*使用位置：一般用在run方法中，参数为毫秒值
*使线程进入休眠状态，这个时候就不会去争夺CPU的执行权
（2）void join() 等待这个线程死亡
*使用位置：一般用在main方法中，一定要在start方法之后使用
*设置为加入线程后，会优先执行
（3）void setDaemon(boolean on)将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
*使用位置：一般用在main方法中，一定要在start方法之前使用
*当被守护线程执行结束之后，守护线程将结束，但是在临死前会挣扎着执行一点代码
6.线程的生命周期 //常见的面试题 ☆☆☆☆☆
//至少要知道有几种状态 最好能 "独立" 画图
新建、就绪、运行、死亡、阻塞
三、多线程的第二种实现方式 ------ 实现Runnable接口的方式 //☆☆☆☆☆
1.实现步骤
（1）定义一个类MyRunnable实现Runnable接口
（2）在MyRunnable类中重写run()方法
（3）创建MyRunnable类的对象
（4）创建Thread类的对象，把MyRunnable对象作为构造方法的参数
（5）启动线程
代码实现：
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
}
}
-----------------------------------------------------------
public class Demo2 {
public static void main(String[] args) {
MyRunnable mr1 = new MyRunnable();
MyRunnable mr2 = new MyRunnable();
Thread t1 = new Thread(mr1);
Thread t2 = new Thread(mr2);
t1.start();
t2.start();
}
}
2.怎么给第二种方式的线程设置名称
*使用setName(String name)来设置名称
Thread t1 = new Thread(mr1);
t1.setName("灰机");
Thread t2 = new Thread(mr2);
t2.setName("火车");
*使用构造方法设置线程名称
Thread t1 = new Thread(mr1,"灰机");
Thread t2 = new Thread(mr2,"火车");
3.获取线程名称
//只能使用一种方式获取
*使用Thread.currentThread().getName()来获取
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+":"+i); //只能使用这种方式来获取线程名称，不能使用this.getName()
}
}
4.两种多线程实现方式的对比
（1）继承Thread类
*只能单继承
*增加了类和类之间的耦合性
（2）实现Runnable接口
*支持多实现
*将"线程"(Thread)和"线程任务"(run)之间解了耦合 //run方法不在线程类中了
//------------------------------------------------------------------------
重点一：properties类
重点二：多线程的两种实现方式
//-----------------------------------------------------------------------
四、买票案例
//问题：多个线程之间是怎么实现共享100张票的？
*实现Runnable接口方式：
将100张票封装在SellTicket类中，创建了一个SellTicket对象，然后将这个对象共享给三个线程，这样的话三个线程就共享了这个对象，也就共享了里面的100张票
*继承Thread类的方式
//使用static修饰ticket，这个时候三个线程类对象就共享了这个静态变量
public class SellTicket extends Thread{
private static int ticket = 100;
@Override
public void run() {
while (true){
if (ticket<=0){
break;
}else{
System.out.println(this.getName()+"正在卖第"+ticket+"张票");
ticket--;
}
}
}
}
----------------------------------------------------------------------------------------------------------------
public class Demo1 {
public static void main(String[] args) {
SellTicket s1 = new SellTicket();
s1.setName("窗口一");
SellTicket s2 = new SellTicket();
s2.setName("窗口二");
SellTicket s3 = new SellTicket();
s3.setName("窗口三");
s1.start();
s2.start();
s3.start();
}
}
1.卖票案例的两个小问题
（1）卖了重复票
（2）卖了负数票
//出现这两个问题的根本原因：CPU的执行权被哪个线程抢到是随机的，具有不确定性
2.安全问题出现的条件
（1）是多线程环境
（2）有共享数据
（3）有多条语句"操作"共享数据 //操作：增、删、改
3.使用同步代码块解决线程安全问题//☆☆☆☆☆
(1)格式
synchronized(任意对象) {
多条语句操作"共享数据"的代码
}
（2）任意对象指的是什么？
其实就是我们所说的锁对象，对于给出什么样的锁对象都无所谓，//但是一定要保证多个线程使用的是同一把锁
（3）大括号到底要包含哪些内容？
//根据共享数据去找
*怎么使用
使用idea自动生成：选中要包含的代码--------使用快捷键CTRL + ALT + T -----------选择synchronized
4.同步方法
（1）同步非静态方法
*格式
修饰符 synchronized 返回值 方法名(参数列表){
xxxxx
}
举例：
public synchronized void sell(){
xxxxx
}
//同步非静态方法的锁对象是谁？
//this
（2）同步静态方法
*格式
修饰符 static synchronized 返回值 方法名(参数列表){
xxxxxxxxx
}
//同步静态方法的锁对象是谁？
类名.class
五、线程安全的类
StringBuilder（线程不安全的、效率高） ---------- StringBuffer（线程安全的、效率低）
ArrayList（线程不安全的、效率高） ------------------ Vector（线程安全的、效率低）
HashMap（线程不安全的、效率高） ------------------Hashtable（线程安全的、效率低）
//面试题：HashMap和HashTable的区别？
HashMap是线程不安全的、效率高 允许null键和null值
Hashtable是线程安全的、效率低 不允许null键和null值
Collections.synchronizedList(new ArrayList<String>());
//线程安全的类之所以安全，是因为在它的底层方法或者代码上加上了synchronized
六、Lock锁 //（不常用）
1.为什么会出现Lock锁
因为Lock锁更加具有面向对象的意思，是用来替代同步代码块的，同步代码块更加具有一点C语言的面向过程的味道
2.相关的类和方法
*构造方法：ReentrantLock() 创建一个ReentrantLock的实例
*相关的方法
void lock() 获得锁
void unlock() 释放锁
3.怎么使用？
synchronized(任意对象) { //---------------------lock.lock();
多条语句操作"共享数据"的代码
} //---------------------lock.unLock();
代码举例：
public void run() {
while (true){
// synchronized (obj) {
lock.lock();
if (ticket<=0){
break;
}else{
//1 //2 //3
System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
ticket--;
}
// }
lock.unlock();
}
}
4.异常处理
try---finally
因为如果在lock()和unLock()方法之间出现了异常，那么就会导致关闭锁资源的代码无法被执行，为了让锁对象一定会被释放，我们就是用finally
//回忆
（1）try --- catch
（2）try ---catch -- finally
（3）try--finally
（4）catch ---finally
（5）try---catch---catch
七、生产者和消费者
//Object类的等待和唤醒方法
void wait() 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
特点：死等 不会自动醒来，除非被唤醒
void notify() 唤醒正在等待对象监视器的"单个"线程 //只能唤醒单个线程
void notifyAll() 唤醒正在等待对象监视器的"所有"线程 //可以唤醒所有线程
//注意：这三个方法必须由锁对象来调用 ☆☆☆☆☆
1.在生产者和消费者模式中，一共出现了几个类？
（1）奶箱类
*奶箱状态
*数量
（2）生产者类
判断奶箱的状态
*有牛奶
不生产---进入等待状态
*没有牛奶
生产牛奶
唤醒消费者线程去消费
改变奶箱的状态为有牛奶
（3）消费者类
判断奶箱的状态
*有牛奶
消费牛奶
唤醒生产者去生产
奶箱的状态改成没有牛奶
*没有牛奶
不消费----进入等待状态
（4）测试类
2.套路 ----针对于生产者和消费者
（1）while（true）
（2）synchronized(){}
（3）判断数量
（4）判断状态
3.作业
吃货吃包子
（1）吃货类
（2）老板类
（3）袋子类 //50个包子
（4）测试类
代码实现：
public class Bag {
public int num = 50;
public boolean status = false; // true代表袋子里有包子 false表示袋子里没有包子
}
----------------------------------------------------------------------------------------------
public class Boss implements Runnable {
private Bag bag;
public Boss(Bag bag) {
this.bag = bag;
}
@Override
public void run() {
while (true){
synchronized (Bag.class){
if (bag.num==0){
break;
}
if (bag.status){
try {
Bag.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
System.out.println("老板正在做第"+bag.num+"个包子");
bag.status=true;
Bag.class.notifyAll();
}
}
}
}
}
--------------------------------------------------------------------------------------
public class ChiHuo implements Runnable {
private Bag bag;
public ChiHuo(Bag bag) {
this.bag = bag;
}
@Override
public void run() {
while (true){
synchronized (Bag.class){
if (bag.num==0){
break;
}
if (!bag.status){
try {
Bag.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
System.out.println("吃货正在吃第"+bag.num+"个包子");
bag.num--;
bag.status=false;
Bag.class.notifyAll();
}
}
}
}
}
--------------------------------------------------------------------------------------
public class Demo1 {
public static void main(String[] args) {
Bag bag = new Bag();
Boss b1= new Boss(bag);
ChiHuo c1 = new ChiHuo(bag);
Thread t1 = new Thread(b1);
Thread t2 = new Thread(c1);
t1.start();
t2.start();
}
}
