java线程
- 一、多线程概述
-
- *1.1 什么是进程？什么是线程？*
- *1.2 进程和线程是什么关系？*
- *1.3 堆和方法区共享，栈独立*
- *1.4 多线程并发的理解*
- 二、java实现线程的三种方式
-
- *2.1 方式一：继承Thread类*
- *2.2 方式二：实现Runnable接口*
- *2.3 方式三：实现Callable接口*
- 三、Thread类
-
- 3.1 线程的生命周期
- *3.2 Thread类的常用方法*
-
- 获取当前线程对象
- 获取线程对象的名字
- 修改线程对象的名字
- 关于线程的sleep方法
- 终止线程睡眠
- 合理终止线程
- *3.3 线程调度（了解*）
-
- 常见的线程调度模型
- 与线程调度有关的方法
- 四、 线程安全（重要）
-
- *4.1 线程安全概述*
- *4.2 synchronized关键字*
-
- 对synchronized的理解
- synchronized的三种写法
- 死锁
- 哪些变量有线程安全问题
- 以后在开发中应该如何解决线程安全问题？
- 五、与线程相关的其他内容
-
- *5.1 守护线程*
- *5.2 定时器*
- *5.3 关于Object类中的wait和notify方法。（生产者和消费者模式！）*
一、多线程概述 1.1 什么是进程？什么是线程？ 进程是一个应用程序（1个进程是一个软件）。
线程是一个进程中的执行场景/执行单元。
一个进程可以启动多个线程。
- 例子：
对于java程序来说，当在DOS命令窗口中输入：java HelloWorld回车之后。会先启动JVM，而JVM就是一个进程，JVM再启动一个主线程调用main方法。同时再启动一个垃圾回收线程负责看护，回收垃圾。最起码，现在的java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。
- 举个例子：
进程可以看做是现实生活当中的公司。 线程可以看做是公司当中的某个员工。 - 注意：
两个进程之间的内存独立，资源不共享。
文章图片
- 使用了多线程机制之后，main方法结束，是不是有可能程序也不会结束？
main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈。
- 对于单核的CPU来说，真的可以做到真正的多线程并发吗？
对于多核的CPU电脑来说，真正的多线程并发是没问题的。4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。
- 【java|Java线程笔记】什么是真正的多线程并发？
多个线程之间，互不干扰，各自执行各自的，这就是真正的多线程并发。
- 单核CPU不能做到真正的多线程并发
单核的CPU表示只有一个大脑：不能够做到真正的多线程并发，单核的CPU在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，可以给人一种“多线程并发”的感觉。
2.1 方式一：继承Thread类 编写一个类，直接继承java.lang.Thread，重写run方法。
// 定义线程类
class MyThread extends Thread {
@Override
public void run() {
for(int i = 0;
i < 1000;
i++){
System.out.println("分支线程--->" + i);
}
}
}
public class ThreadTest {
public static void main(String[] args) {
// 这里是main方法，这里的代码属于主线程，在主栈中运行。
// 新建一个分支线程对象
MyThread t = new MyThread();
// 启动线程
//t.run();
// 不会启动线程，不会分配新的分支栈。（这种方式就是单线程。）
// start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。
// 这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。
// 启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）
// run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。
t.start();
// 这里的代码还是运行在主线程中。
for(int i = 0;
i < 1000;
i++){
System.out.println("主线程--->" + i);
}
}
}
run()和start（）
文章图片
文章图片
2.2 方式二：实现Runnable接口 编写一个类，实现java.lang.Runnable接口，实现run方法。
// 这并不是一个线程类，是一个可运行的类。它还不是一个线程。
public class MyRunnable implements Runnable {
public void run(){
for(int i = 0;
i < 100;
i++){
System.out.println("分支线程--->" + i);
}
}
}public class ThreadTest {
public static void main(String[] args) {
// 创建一个可运行的对象
//MyRunnable r = new MyRunnable();
// 将可运行的对象封装成一个线程对象
//Thread t = new Thread(r);
Thread t = new Thread(new MyRunnable());
// 合并代码
// 启动线程
t.start();
for(int i = 0;
i < 100;
i++){
System.out.println("主线程--->" + i);
}
}
}
注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活。
2.3 方式三：实现Callable接口 FutureTask方式，实现Callable接口。
这种方式的优点：可以获取到线程的执行结果。
这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。
class MyCallable implements Callable {
@Override
public Object call() throws Exception {
// call()方法就相当于run方法，只不过这个有返回值
// 线程执行一个任务，执行之后可能会有一个执行结果
// 模拟执行
System.out.println("call method begin");
Thread.sleep(1000 * 10);
System.out.println("call method end!");
int a = 100;
int b = 200;
return a + b;
//自动装箱(300结果变成Integer)
}
}
public class ThreadTest15 {
public static void main(String[] args) throws Exception {// 第一步：创建一个“未来任务类”对象。
// 参数非常重要，需要给一个Callable接口实现类对象。
FutureTask task = new FutureTask(new MyCallable());
// 创建线程对象
Thread t = new Thread(task);
// 启动线程
t.start();
// 这里是main方法，这是在主线程中。
// 在主线程中，怎么获取t线程的返回结果？
// get()方法的执行会导致“当前线程阻塞”
Object obj = task.get();
// main方法这里的程序要想执行必须等待get()方法的结束
// 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果
// 另一个线程执行是需要时间的。
System.out.println("线程执行结果:" + obj);
System.out.println("hello world!");
}
}三、Thread类 3.1 线程的生命周期
文章图片
3.2 Thread类的常用方法 获取当前线程对象
Thread t = Thread.currentThread();
返回值t就是当前线程。
获取线程对象的名字
String name = 线程对象.getName();
修改线程对象的名字
线程对象.setName("线程名字");
当线程没有设置名字的时候，默认的名字有什么规律？（了解一下）
Thread-0
Thread-1
Thread-2
Thread-3
.....
关于线程的sleep方法
static void sleep(long millis)
- 静态方法：Thread.sleep(1000);
- 参数是毫秒，指定线程睡眠的时间。
- 作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用。可实现间隔特定的时间，去执行一段特定的代码。
- 思考题：
public class ThreadTest07 {
public static void main(String[] args) {
Thread t = new MyThread();
t.setName("t");
t.start();
// 调用sleep方法
try {
// 问题：这行代码会让线程t进入休眠状态吗？
t.sleep(1000 * 5);
// sleep是一个静态方法，在执行的时候还是会转换成：Thread.sleep(1000 * 5);
// 这行代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠。
// 这样代码出现在main方法中，main线程睡眠。
} catch (InterruptedException e) {
e.printStackTrace();
}// 5秒之后这里才会执行。
System.out.println("hello World!");
}
}class MyThread extends Thread {
public void run(){
for(int i = 0;
i < 10000;
i++){
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
终止线程睡眠
void interrupt()
// 终断t线程的睡眠（这种终断睡眠的方式依靠了java的异常处理机制。）
t.interrupt();
// 干扰，一盆冷水过去！
合理终止线程
在java中强行终止一个线程的执行： 调用stop（）方法
这种方式存在很大的缺点：容易丢失数据。因为这种方式是直接将线程杀死了，线程没有保存的数据将会丢失。不建议使用。
合理的终止线程：
在自定义的线程类中打一个布尔标记，你想要什么时候终止线程的执行，把标记修改为false，线程就结束了。
class MyRunable4 implements Runnable {// 打一个布尔标记
boolean run0 = true;
@Override
public void run() {
for (int i = 0;
i < 10;
i++){
if(run0){
//这里可以写执行的代码
}else{
// return就结束了，你在结束之前还有什么没保存的。
// 在这里可以保存呀。
//save....//终止当前线程
return;
}
}
}
}
3.3 线程调度（了解） 常见的线程调度模型
- 抢占式调度模型
哪个线程的优先级较高，哪个抢到的CPU时间片的概率就高一些。
java采用的就是抢占式调度模型。 - 均分式调度模型
平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样，平均分配，一切平等。有一些编程语言，线程调度模型采用的是这种方式。
- 线程的优先级
System.out.println("最高优先级" + Thread.MAX_PRIORITY);
//10
System.out.println("最低优先级" + Thread.MIN_PRIORITY);
//1
System.out.println("默认优先级" + Thread.NORM_PRIORITY);
//5//获取线程优先级：int getPriority()
//设置线程的优先级：void setPriority(int newPriority)
- 让位方法
静态方法：Thread.yield()
暂停当前正在执行的线程对象，回到就绪状态，并执行其他线程。
yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。注意：在回到就绪之后，有可能还会再次抢到。
- 合并线程
void join() 方法
t.join(); // t合并到当前线程中，当前线程受阻塞，t线程执行，直到t线程结束，当前线程才可以继续。
- 线程安全为什么重要？
以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码我们都不需要编写。
最重要的是：你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的。
- 什么时候数据在多线程并发的环境下会存在安全问题呢？
满足以下三个条件之后，就会存在线程安全问题：
条件1：多线程并发。
条件2：有共享数据。
条件3：共享数据有修改的行为。
- 怎么解决线程安全问题呢？
线程同步：用线程排队执行解决线程安全问题，实际上就是线程不能并发了，线程必须排队执行。
- 说到线程同步，涉及到这两个专业术语：
异步编程模型：线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁。其实就是：多线程并发，效率较高。（异步就是并发。）
同步编程模型：线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系。效率较低，线程排队执行。（同步就是排队。）
在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记。（只是把它叫做锁。）
线程t1在遇到synchronized关键字后，会自动在锁池中找共享对象a的对象锁，找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是占有这把锁的，直到同步代码块代码结束，这把锁才会释放。此时其他共享此对象a的线程t2需等待t1的结束，才能有机会获取对象a的对象锁，这样就达到了线程排队执行。
synchronized的三种写法
1. 同步代码块：灵活
synchronized(线程共享对象){
同步代码块;
}
synchronized后面小括号中传的这个“数据”是相当关键的。这个数据必须是多线程共享的数据，才能达到多线程排队。你想让哪些线程同步，就在小括号中填入这些线程共享的对象。
2. 在实例方法上使用synchronized： 不灵活但简洁
synchronized出现在实例方法上，一定锁的是this。没得挑，只能是this。不能是其他的对象了，所以这种方式不灵活。
另外还有一个缺点：synchronized出现在实例方法上，表示整个方法体都需要同步，可能会无故扩大同步的范围，导致程序的执行效率降低，所以这种方式不常用。
3. 在静态方法上使用synchronized： 表示找类锁
类锁永远只有1把，就算创建了100个对象，那类锁也只有1把。
对象锁：1个对象1把锁，100个对象100把锁。
类锁：100个对象，也可能只是1把类锁。
死锁
死锁代码：
public class DeadLock {
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
// t1和t2两个线程共享o1,o2
Thread t1 = new MyThread1(o1,o2);
Thread t2 = new MyThread2(o1,o2);
t1.start();
t2.start();
}
}class MyThread1 extends Thread{
Object o1;
Object o2;
public MyThread1(Object o1,Object o2){
this.o1 = o1;
this.o2 = o2;
}
public void run(){
synchronized (o1){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o2){}
}
}
}class MyThread2 extends Thread {
Object o1;
Object o2;
public MyThread2(Object o1,Object o2){
this.o1 = o1;
this.o2 = o2;
}
public void run(){
synchronized (o2){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o1){}
}
}
}
以上代码会出现死锁现象，发生死锁既不会出现异常，也不会出现错误，程序一直僵持，所以死锁很难调试。所以synchronized在开发中最好不要嵌套使用，容易导致死锁。
哪些变量有线程安全问题
Java中有三大变量：
实例变量：在堆中。
静态变量：在方法区。
局部变量：在栈中。
以上三大变量中：
局部变量永远都不会存在线程安全问题。因为局部变量在栈中，一个线程一个栈。所以局部变量永远都不会共享。常量也不会有线程安全问题。
实例变量在堆中，堆只有1个；静态变量在方法区中，方法区只有1个。堆和方法区都是多线程共享的，所以可能存在线程安全问题。
如果使用局部变量的话：
建议使用：StringBuilder。因为局部变量不存在线程安全问题，选择StringBuffer效率比较低。
ArrayList是非线程安全的。
Vector是线程安全的。
HashMap、HashSet是非线程安全的。
Hashtable是线程安全的。
以后在开发中应该如何解决线程安全问题？
第一种方案：尽量使用局部变量代替“实例变量和静态变量”。
第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了。）
第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了，线程同步机制。synchronized会让程序的执行效率降低，系统的用户吞吐量降低，用户体验差。在不得已的情况下再选择线程同步机制。
五、与线程相关的其他内容 5.1 守护线程
- java语言中线程分为两大类：
用户线程 ：主线程main方法是一个用户线程。
守护线程（后台线程）：垃圾回收线程就是一个具有代表性的例子。
- 守护线程的特点：
一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。
- 守护线程用在什么地方呢？
每天00:00的时候系统数据自动备份。这个需要使用到定时器，并且我们可以将定时器设置为守护线程。一直在那里看着，每到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。
- 守护线程的实现：
// 启动线程之前，将线程设置为守护线程（调用setDaemon方法，传入ture值） 线程对象.setDaemon(true);
在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，那么在java中其实可以采用多种方式实现：
- 可以使用sleep方法，睡眠，设置睡眠时间，每到这个时间点醒来，执行任务。这种方式是最原始的定时器。（比较low）
- 在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
- 在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。而SpringTask框架的底层实现原理就是java.util.Timer
/*
使用定时器指定定时任务。
*/
public class TimerTest {
public static void main(String[] args) throws Exception {// 创建定时器对象
Timer timer = new Timer();
//Timer timer = new Timer(true);
//守护线程的方式// 指定定时任务
//timer.schedule(定时任务, 第一次执行时间, 间隔多久执行一次);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date firstTime = sdf.parse("2020-03-14 09:34:30");
timer.schedule(new LogTimerTask() , firstTime, 1000 * 10);
// 编写一个定时任务类
// 假设这是一个记录日志的定时任务
class LogTimerTask extends TimerTask {@Override
public void run() {
// 编写你需要执行的任务就行了。
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strTime = sdf.format(new Date());
System.out.println(strTime + ":成功完成了一次数据备份！");
}
}
5.3 关于Object类中的wait和notify方法。（生产者和消费者模式！） wait和notify方法不是线程对象的方法，是Object类中自带的，是普通java对象都有的方法。wait方法和notify方法建立在线程同步的基础之上。因为多线程要同时操作一个仓库，有线程安全问题。
wait方法作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁。
notify方法作用：o.notify()随机唤醒一个正在o对象上等待的线程，只是通知，不会释放o对象上之前占有的锁。
notifyAll()方法作用：o.notifyAll()唤醒所有正在o对象上等待的线程
推荐阅读
- java|你还在用JWT做身份认证嘛（）
- 相关|JWT讲解
- Java|JWT入门教程
- 重地和通话的哈希值（hash）为何相同?
- c语言|C/JAVA 每日一练——零基础学习动态规划
- 第l个数到第r个数中第K大的数是哪个———蓝桥杯
- java|蓝桥杯第五届省赛java试题及解析（不断更新）
- 还在用递归，试试迭代吧
- 如何在Quarkus 框架中使用 Native Image