线程基础

很不严谨的说，线程是什么？线程就是为了让很多个东西并发执行，大大的提高程序执行的效率啊

三个非常重要的概念：

程序：一组写好了的静态代码块（就我们写的那些代码玩意）
进程：正在进行着的程序，即静态的代码执行起来了
线程：是进程的小单元，或者说多个线程构成一个进程（线程的出现是因为进程满足不了人们的需求，于是进程被细化了）

线程的转换（五个较为简单的转换）可以通过这个图了解一下：
在这里插入图片描述
在Java中，

线程有三类：

主线程：系统线程，如Java中的Java虚拟机（主线程是最先执行的）
用户线程：Java中main函数执行的那些玩意
守护线程（精灵）：比如Java中的GC（垃圾回收器，他是为主线程服务的，当系统启动后，GC就随之产生了；Java虚拟机断掉了，GC也就不干活了）

线程是操作系统层次的（又或者说是cpu层次的，进程怎么执行的，顺序是啥。。。这些都是靠cpu分配的）
不过线程怎么去用，Java的JDK已经给我们写好了
在这里插入图片描述
实现线程的过程（有两个方法）：

自己描述一个类
实现线程的两个前提条件（继承Thread是最方便的，但是Java是单继承的，很可能会和其他的继承冲突；所以还可以通过实现Runnable接口，不过它要额外的通过写一个Thread类来执行start()方法）：
- 方法一：继承一个父类Thread
- 方法二：实现一个接口Runnable
我们都必须重写run()方法，
因为这个方法来源于cpu，是操作系统给JDK提供的接口，JDK将它包装成run()，其实我们执行的线程就是写在run()方法中的代码执行起来了
new一个线程对象（我们是无法调用run()的，它只有cpu才可以调用，cpu分配时间碎片才能开始执行）
我们只能调用start()方法（这个方法继承自Thread），它会使这个线程除了cpu资源的其它资源都得到满足，让它进入就绪状态，在就绪队列中等待着cpu执行它

（补充：为什么要这么麻烦呢？为什么不直接使用Thread类或者Runnable接口，直接在里面写线程的代码，但是run()方法是不允许有参数的，我们一般要执行的线程都要传参数，所以只能通过继承和实现来解决参数传递的问题）

【一个例子】实现线程的两种方式

继承一个父类 Thread，可以看到调用线程时写法较为简单

public class Running extends Thread {String name;public Running(String name){this.name = name;}@Overridepublic void run() {for(int i = 1; i <= 10; i++){System.out.println(name + "跑到了" + i + "米");}}public static void main(String[] args) {Running Lux = new Running("Lux");Running Ahri = new Running("Ahri");Running Annie = new Running("Annie");//从Thread类中继承过来的方法Lux.start();Ahri.start();Annie.start();}
}

实现一个接口 Runnable，可以看到调用线程时写法复杂一些

public class Running implements Runnable {String name;public Running(String name){this.name = name;}@Overridepublic void run() {for(int i = 1; i <= 10; i++){System.out.println(name + "跑到了" + i + "米");}}public static void main(String[] args) {Running Lux = new Running("Lux");Running Ahri = new Running("Ahri");Running Annie = new Running("Annie");//Thread类中才有start()方法Thread thread1 = new Thread(Lux);thread1.start();Thread thread2 = new Thread(Ahri);thread2.start();Thread thread3 = new Thread(Annie);thread3.start();}
}

多次运行线程代码，发现线程无论执行顺序，还是开始执行时间都是随机的（实际上是操作系统通过算法调度和分配资源，JDK是不能影响它的）

我们只需要类中继承或实现线程，重写run()方法，最后调用start()方法就可以了

我们不要直接调用run()方法，这样就不是多线程了，只是按顺序执行的单线程！！！

模拟一个火车站售票小例子

使用控制台输入输出，仅仅是为了简单玩一下线程，例子很简陋
三个类
- 车票
- 售票系统12306
- 售票窗口
代码：github
效果展示：

从广州北站售出:[ 北京11 --> 深圳11 : 150.0 ]
从广州西站售出:[ 北京10 --> 深圳10 : 125.0 ]
从广州南站售出:[ 北京12 --> 深圳12 : 175.0 ]
从广州西站售出:[ 北京14 --> 深圳14 : 225.0 ]
从广州南站售出:[ 北京15 --> 深圳15 : 125.0 ]
...
...
对不起广州南站窗口车票已售完
对不起广州西站窗口车票已售完
对不起广州北站窗口车票已售完

多线程同时读取一个文件

题目：有一个26字节的文件 test.txt，里面按顺序存储着26个小写英文字母，使用3个线程同时读取
使用控制台输入输出，仅仅是为了简单玩一下线程与IO，例子很简陋
分析：
- 使用字节型输入流，使用skip()方法
- 1号线程：读取1-10字节
- 2号线程：读取11-20字节
- 3号线程：读取21-26字节
代码：github
效果展示：

Thread-0读取：a
Thread-2读取：u
Thread-1读取：k
Thread-2读取：v
Thread-0读取：b
Thread-2读取：w
...
...

生产消费者模型

我创建一个生产者向仓库添加物品
和两个消费者向仓库中拿走物品

在多线程并发进行中会出现这么一种问题：
在这里插入图片描述
如果仓库只剩一个物品时，出现了这么一个顺序

消费者1进行判断（还剩一个）
消费者2进行判断（还剩一个）
消费者1执行get方法
- get方法作用是：获取物品
消费者2执行get方法（这时候就出现问题了，虽然判断时仓库还有一个可以拿；但是到执行get方法时，仓库是空的，那么问题出现了：多线程并发抢夺资源）

生产者消费者模型：
- 模拟上述描述的问题，并且代码中不涉及其余线程操作，只会出现生产者消费者模型的问题
- 三个类：Producer、Consumer、WareHouse
- 分别代表：生产者、消费者、仓库
代码：github
不出所料，在执行的过程中出现问题了
两个消费者，成功演示出了线程安全问题；两个消费者并发访问，可能产生抢夺资源的问题；所以多个线程并发执行的时候，有安全隐患

synchronized

生产者消费者模型解决办法：
- 让仓库被线程访问的时候，仓库对象被锁定（即仓库对象只能被一个线程访问，其它的线程处于等待状态）
- 使用一个特征修饰符即可synchronized，又称为线程安全锁，表示同步的意思，作用：一个时间点只有一个线程访问
- 给仓库提供的获取物品的方法（get）加上线程安全锁，可以避免多线程并发抢夺资源

synchronized 有两种写法：

将synchronized关键字，放在方法的结构上（特征修饰符），其实它锁定的是synchronized修饰方法所在的对象，由调用该方法的线程锁定

public synchronized void test(){代码}

将synchronized关键字，放在方法（/构造方法/块）内部

public void test(){很多代码synchronized(对象){   //只有方法执行到这里的时候才被锁定//锁定哪个对象呢？可以由synchronized()的参数决定某些代码}很多代码
}

第二种写法性能更加棒；而且更为灵活，给内部的synchronized(){}的参数传对象，不仅可以由调用方法的线程锁定，还可由其他线程对象来锁定

线程对象改变引起的异常

如果线程调用的方法中有wait()和notify()/notifyAll()方法，但是没有加synchronized线程安全锁时会出现一种异常：java.lang.IllegalMonitorStateExceptionr
注意：wait和notify需要成对出现，或者wait和notifyAll成对出现，否则可能出现假死锁
- wait() 线程等待
- notify() 唤醒某个线程
- notifyAll() 唤醒所有线程
- wait() notify() notifyAll()都是Object的方法，但和synchronized关键字一样，也是哪个线程调用则对哪个线程起作用

在生产者消费者模型代码基础上进行修改，仓库的获取物品与存放物品的方法不加线程安全锁，并且使用线程等待与线程唤醒方法
在这里插入图片描述
这就是张冠李戴的字面解释了，当访问仓库的生产者线程等待，告知生产者的这一刹那，对象变成了另一个线程：该等待的没有等待，不该等待的等待了

join

join()方法也是Thread类中的方法，挺有用的
可以让两个并行的线程变成单线程

线程创建好之后，我们不能控制线程执行的先后顺序，我们只能让线程进入就绪状态

【例子】首先来回顾一下线程并发执行的情况，以线程ThreadOne与ThreadTwo为例：

ThreadOne one = new ThreadOne();
ThreadTwo two = new ThreadTwo();
one.start();
two.start();

one执行，one结束，two执行，two结束
one执行，two执行，one结束，two结束
one执行，two执行，two结束，one结束
…

【例子】如果有两个线程ThreadOne和ThreadTwo，我想让ThreadTwo加入到ThreadOne中，可以这么写：

ThreadOne

public class ThreadOne extends Thread {public void run() {System.out.println("thread-one start");ThreadTwo two = new ThreadTwo();two.start();try {two.join();//线程2加入到线程1中} catch (InterruptedException e) {e.printStackTrace();}System.out.println("thread-one end");}
}

ThreadTwo

public class ThreadTwo extends Thread{public void run() {System.out.println("thread-two start");try {Thread.sleep(5000);//睡眠5秒} catch (InterruptedException e) {e.printStackTrace();}System.out.println("thread-two end");}
}

在main中，调用ThreadOne线程的start()方法：
在这里插入图片描述

这里用的是join()的无参方法，thread-one启动后，必须要等着thread-two执行完，才能往后面执行
join(millis)还有一个有参重载方法

将ThreadOne类中的 two.join() 改为 two.join(4000)

thread-one启动后，不是必须等待着thread-two执行完，而是等待4000毫秒如果thread-two还没执行完，thread-one就继续往后执行
在这里插入图片描述

join源码结合例子分析

【join源码】

无参的 join() 方法：

public final void join() throws InterruptedException {join(0);//还是会调用有参的join方法
}

有参的 join() 方法：

public final synchronized void join(long millis) throws InterruptedException {long base = System.currentTimeMillis();long now = 0;if (millis < 0) {throw new IllegalArgumentException("timeout value is negative");}if (millis == 0) { //这就是调用无参join时的执行代码while (isAlive()) {wait(0);}} else {while (isAlive()) {long delay = millis - now;if (delay <= 0) {break;}wait(delay);now = System.currentTimeMillis() - base;}}
}

ThreadOne类中调用的无参 two.join() 时
- 只要 ThreaTwo 活着，那么 ThreadOne 就一直是等待状态

while (two.isAlive()) {two.wait(0);
}

ThreadOne类中调用的有参且参数大于0 two.join(4000) 时
- ThreaTwo 活着的期间，ThreadOne 等待millis毫秒后打破循环，即不再等待了

while (two.isAlive()) {long delay = millis - now;if (delay <= 0) {break;}two.wait(delay);now = System.currentTimeMillis() - base;
}

join遇上线程安全锁

感受一下 synchronized 的强大吧
- 三个线程类：ThreadOne、ThreadTwo、ThreadThree
- ThreadOne 中调用 ThreadTwo，并 two.join(2000);，不过 ThreadTwo 需要执行5秒
- ThreadTwo 中调用 ThreadThree，并将自身通过参数传给 ThreadThree
- ThreadThree 通过 synchronized 将 ThreadTwo 锁起来10秒
代码：github
执行效果：

one启动
two启动
three启动
two就join进one中了（two要执行5000毫秒，但是one只给了two2000毫秒）
2000毫秒之后，one想要把two从自己的线程中剔除掉；但是发现，two已经不在自己的手中，two已经被three锁定（要被锁定10000毫秒）
one只能等待three将two释放后才能剔除掉two

所以，锁是非常强大滴

死锁

synchronized非常厉害，一旦线程被锁定，不释放的情况，其它的线程都需要等待
如果锁没用好，有可能产生死锁的问题（互相都想要对方的资源，却都得不到满足）

这么说吧，
Ahri手里有a资源，然后需要b资源
Lux手里有b资源，然后需要a资源
而且，a资源被Ahri独占了，其它进程拿不到；b资源被Lux独占了，其它进程都拿不到
那么：
Ahri得不到Lux的b资源
Lux得不到Ahri的a资源
就会这样：
Ahri和Lux一直等着对方释放资源

这就是死锁

哲学家进餐问题

哲学家进餐问题 是一个著名的死锁问题：
在这里插入图片描述
四个人在餐桌上吃饭，但是只有四只筷子，
四个人同时拿筷子，
而且要求，每一个人先拿左手边的筷子，然后拿右手边的筷子

所以嘛，有可能他们四个人拿筷子的速度恰好一样，都拿了左手边的筷子，于是僵持住了

代码：github

避免死锁的方法：

礼让----产生时间差
不要产生共用的问题

有趣的Timer类

计时器/定时器是JDK已经写好了的线程类
java.util包，Timer类

【小例子】用Timer类模拟一个短信轰炸的效果（每隔一段时间发送信息）

Timer有这么一个方法schedule()，有四个重载方法
在这里插入图片描述
对上面出现的参数的解释

TimerTask task表示一个任务，以字符串形式表示
TimerTask是一个抽象类，new不了的，不过可以使用匿名内部类对象
Date time、Date firstTime表示起始时间（到了起始时间，任务开始执行）
long delay表示延迟时间（及延迟给的时间后，任务开始执行）
long period周期，表示多长时间后再干一次，是一个循环

短信轰炸

//导包
//...
public class TestTimer {private int count = 1;//记录轰炸次数ArrayList<String> userBox = new ArrayList<>();//存储众多个人信息{userBox.add("a"); userBox.add("b"); userBox.add("c"); userBox.add("d");}启动一个小线程，记录时间，可以每隔一段时间去做一件事情public void test() throws ParseException {System.out.println("开始啦");Timer timer = new Timer();SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date firstTime = sdf.parse("2020-07-27 16:30:00");timer.schedule(new TimerTask() {public void run() {System.out.println("第" + count++ + "次执行");for(int i = 0; i < userBox.size(); i++){System.out.println("给" + userBox.get(i) + "发送了一条消息：陌生人祝你幸福");}System.out.println("做了点坏事儿 真开心~~~");}},firstTime,3000);}public static void main(String[] args) {TestTimer demo = new TestTimer();try{demo.test();}catch (ParseException e){e.getErrorOffset();}}}