偷偷学习Java，然后惊艳所有人 JavaSE总结 - thread多线程
零基础学Java，肝了bilibili的6百多集JavaSE教程传送门的学习笔记！！！
下面博客分为三部分：
- ① thread多线程的要点（想快速了解thread多线程的小伙伴选择，内容较多，快也快不了）
- ② 案例代码的初步简洁介绍（小伙伴要学哪个看哪个）
- ③ 案例代码，对②中的知识点进行解释（需要再花费30分钟学习的小伙伴选择）
一、thread多线程的要点
(一)、进程与线程
1、什么是进程？什么是线程？
进程是一个应用程序（1个进程可以先看成一个软件）， 线程是一个进程中的执行场景/执行单元
一个进程可以启动多个线程
2、对于java程序来说，当在DOS命令窗口中输入：java HelloWorld 回车之后,会先启动JVM，而JVM就是一个进程。
JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。
最起码，现在java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。
3、线程和进程是什么关系？
注意：
进程A和进程B的内存独立不共享。 在java语言中，线程A和线程B，堆内存和方法区内存共享。 但是栈内存独立，一个线程一个栈。
假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。
多线程目的：提高程序的处理效率
4、思考一下： 使用了多线程之后，main方法结束，是不是有可能程序也不会结束。
main方法结束只是主线程结束了，主栈空了，其他的栈(线程)可能还在压栈弹栈。
对于单核的cpu来说，可以做到真正的多线程并发吗？
什么是真正的多线程并发？t1线程执行t1的。 t2新城执行t2的。 t1不会影响t2，t2也不会影响t1.
5、线程的实现
方式一：编写一个类，直接继承java.lang.Thread，重写run方法
java支持多线程机制。并且Java已经将多线程实现了，我们只需要继承就行。
方式二：编写一个类，实现java.lang.Runnable接口，实现run方法
注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其他的类，更灵活。
（二）、关于线程调度(了解内容)
1、常见的线程调度模型又哪些呢?
①抢占式调度模型：那个线程的优先级高，抢到的CPU时间片的概率就高一些。
java就是采用这种调度模型。
②均分式调度模型：平均分配CPU时间片，每个线程占有的CPU时间片时间片段长度一样。
平均分配，一切平等。
2、java中提供了哪些方法是由线程调度有关系的呢？
实例方法：
void setPriority(int newPriority)设置线程的优先级
int getPriority()获取线程优先级
最低优先级：1
最高优先级：10
默认优先级：5
静态方法：
void join():合并线程(多线程变成单线程)
static void yield()：让位方法,暂停当前正在执行的线程对象，并执行其他线程
yield()不是阻塞方法，让当前线程让位，让给其他线程使用。
yield()方法的执行会让当前线程从"运行状态"回到"就绪状态"
注意：回到"就绪状态"还有可能再次抢到
// 知识点2 (上方)
class MyThread extends Thread {
public void doSome{
MyThread2 t = new MyThread2();
t.join(); 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以执行。
}
}
class MyThread2 extends Thread {
}
3、关于多线程并发环境下，数据的安全问题
3.1、为什么这个是重点？
以后在开发中，我们的项目都是运行在服务器当中。
而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。 这些代码我们都不需要编写。
最重要的是：你要知道，你编写的程序需要放到一个多线程的环境下运行，
你更需要关注的是这些数据在多线程并发的环境下是否是安全的。
3.2、什么时候数据在多线程并发的环境下会发生安全问题？
三个条件：
- 多线程并发
- 有共享数据
- 共享数据有修改的行为
满足以上三个条件之后，就会存在线程安全问题
3.3、 怎么解决线程安全问题呢？ ——
使用“线程同步进制”
当多线程并发的环境下，有共享数据，并且这个数据还会被修改
此时就存在线程安全问题，如何解决？
线程排队执行。(不能并发，并发效率高，但是数据不安全)
- 用排队执行解决线程安全问题。
- 这种机制被称为：线程同步机制。
- 线程同步就是线程排队了，线程排队了就会牺牲一部分效率。没办法！数据安全第一位，只有数据安全了，我们才可以谈效率。
3.4、说到线程同步这块，涉及到两个专业术语：
① 异步编程模型：
线程t1和线程t2，各自执行各自的，互不干扰，谁也不需要等谁。
其实就是：多线程并发(效率较高)
② 同步编程模型：
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，
或者说在t2线程执行的时候，必选等待t1线程执行结束。
两个线程之间发生了等待关系，这就是同步编程模型。
效率较低。线程排队执行。
4、Java中有三大变量【重要知识点】
- 实例变量：在堆中
- 静态变量：在方法区
- 局部变量：在栈中
以上三大变量中：
局部变量永远都不会存在线程安全问题。
因为局部变量不会共享。(一个线程一个栈)
局部变量在栈中，所以局部变量永远都不会共享。
实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。
常量没有线程安全问题，因为其不可修改。
如果的使用局部变量的话：
建议使用：stringBuilder
因为局部变量不存在线程安全问题。
选择StringBuilder，StringBuffer效率较低。
线程安全：
Vector
Hashtable
非线程安全：
ArrayList
HashMap HashSet
5、总结：
synchronized的三种写法：
1、同步代码块
灵活
synchronized(线程共享对象) {
}
2、在实例方法上使用synchronized
表示共享对象一定是this。
并且同步代码块是整个方法快
3、在静态方法上使用synchronized
表示找类锁。
类锁永远只有1把，就算创建了100个对象，类锁也只有1把。
对象锁：1个对象1把对象锁，100个对象100把锁。
类锁：100个对象，也可能只是1把类锁。（类锁就是为了保护静态变量的安全）
6、聊一聊：开发中这么解决线程安全问题？
是一上来就选择线程同步吗？synchronized
不是，synchronized会让线程的执行效率降低，用户体验不好。
系统的用户吞吐量(并发量)降低。用户体验查。在不得已的情况下再选择线程同步机制
第一种方案：尽量使用局部变量代替"实例变量和静态变量"
第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。
(一个线程对应1个对象，100个线程对应100个对象，对象不共享就没有数据安全问题了。)
第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized—— 线程同步机制。
7、线程知识点还有哪些内容呢？
7.1、守护线程
java语言中线程分为两大类：
1、用户线程
2、守护线程（后台线程）
- 其中具有代表性的就是：垃圾回收线程（守护线程）
守护线程的特点：
一般守护线程是一个死循环，所有的用户线程只有结束，
守护线程自动结束。
注意：主线程main方法是一个用户线程
守护线程用在什么地方呢？
例如：每天00:00的时候系统数据自动备份
这个需要使用到定时器，并且我们可以将定时器设置为守护线程。
一直在那里看着，没到00:00的时候就备份一次。
所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。
7.2、定时器
定时器的作用：间隔 "特定的时间" 执行 "特定" 的程序
例如：每周要进行银行账户的总账操作。
每天要进行数据的备份操作。
在实际的开发中，每个多久执行一段特定的程序，这种需求是很常见的。
那么在java中其实可以采用多种方式实现：
①、可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行任务。
但这种都是是最原始的定时器。（比较low）
②、在java的类库中已经写好了一个定时器：java.util.Time,可以直接拿来用。
不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
③、在实际的开发中，目前使用较多的是spring框架中提供的springTask框架，
这个框架只要进行简单的配置，就可以完成定时器的任务。
7.3、实现线程的第三种方式：FutureTask方式，实现Callable接口(JDK8新特性)
这种方式实现的线程可以获取线程的返回值。
之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。
思考：
系统委派一个线程去执行一个任务，该线程执行任务之后，可能会有一个执行结果，我们怎么能拿到这个执行结果呢？
答：使用第三种方式：实现Callable接口
7.4、关于Object类中的wait和notify方法（生产者和消费者模式）
1、wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，
因为这两个方法是Object类中自带的。
wait方法和notify方法不是通过线程对象调用的。
不是这样的：t.wait(), 也不是这样的：t.notify()… 不对
2、wait方法作用
Object o = new Object();
o.wait();
表示：让正在o对象上活动的线程（当前线程）进入等待状态，无期限等待，直到被唤醒。
3、notify方法作用
Object o = new Object();
o.ontify();
表示：
唤醒正在o对象上等待的线程。
还有一个notifyAll()方法：这个方法是唤醒o对象上处于等待的所有线程。
二、代码介绍
- ThreadTest01.java: 判断程序有几个线程
- ThreadTest02.java: 线程实现方法一
- ThreadTest03.java: 线程实现方法二
- ThreadTest04.java: 使用匿名内部类实现线程
- ThreadTest05.java: 获取线程的名字
- ThreadTest06.java: sleep
- ThreadTest07.java: 关于sleep的面试题
- ThreadTest08.java: 终止sleep休眠
- ThreadTest09.java: 强行终止线程的执行
- ThreadTest10.java: 合理终止线程的执行
- ThreadTest11.java: 线程优先级
- ThreadTest12.java: 线程让位
- ThreadTest13.java: 线程合并
- 实现账户取款案例 Account.java + AccountThread.java + AccountTest.java
- 创建一个thread.test package
Account.java + AccountThread.java + AccountTest.java
synchronized同步代码块解决账户取款隐患
- 创建一个thread.test2 package：加深对synchronized的使用理解
- thread.exam package 面试题
- ThreadTest14.java: 守护线程
- ThreadTest15.java: 定时器
- ThreadTest16.java: 实现线程的第三种方式
- ThreadTest17.java: 实现生产者和消费者模式
三、案例代码
01、ThreadTest01.java
package keywords.thread多线程;
// 程序只有一个栈(只有一个线程)
public class ThreadTest01 {
public static void main(String[] args) {
System.out.println("mian begin");
m1();
System.out.println("main over");
}
private static void m1() {
System.out.println("m1 begin");
m2();
System.out.println("m1 over");
}
private static void m2() {
System.out.println("m2 begin");
m3();
System.out.println("m3 over");
}
private static void m3() {
System.out.println("m3 execute!");
}
}
02、ThreadTest02.java
如何创建线程对象？ new就行了
怎么启动线程呢？调用线程对象对的start()方法
package keywords.thread多线程;
public class ThreadTest02 {
public static void main(String[] args) {
// main方法，这里的代码属于主线程，在主栈中运行。
// 新建一个分支线程对象。
MyThread myThread = new MyThread();
// 启动分支线程
// start()方法的作用是： 启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后瞬间就结束了。
// 这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。
// 启动成功的线程会自动调用run方法，并且run方法在分支线程的栈底部(压栈)。
// run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。
myThread.start();
// myThread.run(); // 不会启动线程，不会分配新的分支栈（单线程,不能并发)
/* myThread.start();不结束是不是下面代码不执行？
*
* 对，java代码执行就是从上往下进行，
* myThread.start();不执行完下面的代码就不会执行。
*
* 只是myThread.start()是瞬间结束的，因为它的任务是启动分支栈，启动成功就执行结束了，就执行下一行代码了。
* 此时分支线程也在执行。
*/
// 这里的代码运行在主线程中
for (int i = 0; i < 100; i++) {
System.out.println("主线程 - - -》" + i);
}
}
}
class MyThread extends Thread {
@Override
public void run(){
// 编写程序，这段程序运行再分支线程中(分支栈)。
for (int i = 0; i < 100; i++) {
System.out.println("分支线程 - - -》" + i);
}
}
}
03、ThreadTest03.java
package keywords.thread多线程;
public class ThreadTest03 {
public static void main(String[] args) {
// 创建一个可运行的对象
MyRunnable r = new MyRunnable();
// 将可运行的对象封装成一个线程对象
Thread t = new Thread(r);
// 启动线程
t.start();
for (int i = 0; i < 100; i++) {
System.out.println("主线程 - - -》" + i);
}
}
}
// 这并不是一个线程类，只是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("分支线程 - - -》" + i);
}
}
}
04、ThreadTest04.java
package keywords.thread多线程;
public class ThreadTest04 {
public static void main(String[] args) {
// 创建线程对象，采用匿名内部类方式。
// 这是通过一个没有名字的类，new出来的对象。
Thread t = new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0; i < 100; i++) {
System.out.println("t线程- - -》" + i);
}
}
});
// 启动线程
t.start();
for(int i = 0; i < 100; i++) {
System.out.println("主线程- - -》" + i);
}
}
}
5、ThreadTest05.java
1、怎么获取当前线程对象？
static Thread.currentThread()
Thread t = Thread.currentThread();
这个t就是当前线程
2、获取线程对象的名字
String name = 线程对象.getName();
3、修改线程对象的名字
线程对象.setName("线程名字");
4、当线程没有设置名字的时候，默认的名字有什么规律？
Thread-0
Thread-1
Thread-2
…
package keywords.thread多线程;
public class ThreadTest05 {
public static void main(String[] args) {
// currentThread就是当前线程
// 这个代码出现在main方法中，所以当前线程就是主线程
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName());
// System.out.println(super.getName()); // 此处会报错，static里不行
// System.out.println(this.getName());
// 创建线程对象
MyThread2 myThread2 = new MyThread2();
// 设置线程名字
// myThread2.setName("t2"); // 不设置时，默认：Thread-0、Thread-1……
// 获取线程名字
String name = myThread2.getName();
System.out.println(name);
// 启动线程
myThread2.start();
}
}
class MyThread2 extends Thread {
public void run() {
for (int i = 0; i < 100; i++) {
Thread thread = Thread.currentThread();
System.out.println(thread.getName());
// System.out.println(super.getName());
// System.out.println(this.getName());
// 此处以上三种写法都可行，后面两种只有刚好是线程类就可以，不建议使用
System.out.println("分支线程- - - >" + i);
}
}
}
06、ThreadTest06.java
关于线程的sleep方法：
static void sleep(Long millis)
1、静态方法：Thread.sleep(1000);
2、参数为毫秒
3、作用：让当前线程进入休眠，进入"阻塞状态",放弃占有CPU时间片，让给其他线程使用。
这行代码出现在A线程，A线程就会进入休眠。
这行代码出现在B线程，B线程就会进入休眠。
4、Thread.sleep()方法，可以做到这样的效果：
间隔特定的事件，去执行一段特定的代码，每隔多久执行一次
package keywords.thread多线程;
public class ThreadTest06 {
public static void main(String[] args) {
// 让当前进程睡眠5秒
// 当前线程就是main方法
/*
try {
Thread.sleep(1000*5);
} catch (InterruptedException e) {
e.printStackTrace();
}
*/
// System.out.println("5秒之后输出");
// 计时器
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--->" +i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
07、ThreadTest07.java
package keywords.thread多线程;
public class ThreadTest07 {
public static void main(String[] args) {
Thread t3 = new MyThread3();
t3.setName("t3");
t3.start();
try {
// 问题：这行代码会让线程t3进入休眠状态吗？
// t3.sleep(1000 * 5);
Thread.sleep(1000*5); // 上一行代码执行效果
/* 不会，sleep是静态方法，与对象没有关系
* 在执行的时候还是会转换成：Thread.sleep(1000*5);
* 这行代码得作用是：让当前线程进入休眠，也就是说main线程进入休眠。
* 因为这行代码出现在main方法
*/
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("……………… over");
}
}
class MyThread3 extends Thread {
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
08、ThreadTest08.java
sleep睡眠太久了，如果希望半道上醒过来，应该这么办？也就是说
怎么叫醒一个正在睡眠的线程？
注意:
这个不是中断线程的执行，是终止线程的睡眠。
package keywords.thread多线程;
public class ThreadTest08 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable2());
t.setName("t");
t.start();
// 希望5s之后t线程醒过来(因为5s之后主线程的活都干完了)
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 终断t线程的睡眠(这种终断睡眠的方式依赖了java的异常处理机制)
t.interrupt(); // 干扰，就好像一盆冷水过去，就醒过来了
// java.lang.InterruptedException: sleep interrupted
// 睡眠被终断 (不是中断)
}
}
// 注意一点：run()当中的异常不能使用throws，只能try-catch
// 因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常
class MyRunnable2 implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "---> begin");
try {
Thread.sleep(1000 * 60 * 60 * 24 * 365);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 一年之后才会执行
System.out.println(Thread.currentThread().getName() + "---> end");
}
// 此处方法不是继承的方法，可以throws
/*
* public void doOther() throws Exception {
*
* }
*/
}
09、ThreadTest09.java
package keywords.thread多线程;
public class ThreadTest09 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable3());
t.setName("t");
t.start();
// 模拟5s
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 5s之后强行终止t线程
// t.stop(); // 表示已过时(不建议使用)
/**
* t.stop(); 这种方式又很大的缺点：容易丢失数据。
* 因为这种方法是直接把线程杀死了，线程没有保存的数据将丢失。
*
*/
}
}
class MyRunnable3 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--->" +i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
10、ThreadTest10.java
package keywords.thread多线程;
public class ThreadTest10 {
public static void main(String[] args) {
MyRunnable4 r = new MyRunnable4();
Thread t = new Thread(r);
t.setName("t");
t.start();
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 你想什么时候终止t的执行，把标记改为false就结束了
r.run = false;
}
}
class MyRunnable4 implements Runnable {
// 打一个布尔标记
boolean run = true;
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if(run) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
// 在return结束之前，还有什么没保存的可以在这里保存
// save...
// 终止当前线程
return;
}
}
}
}
11、ThreadTest11.java
package keywords.thread多线程;
public class ThreadTest11 {
public static void main(String[] args) {
/*
* System.out.println("最高优先级" + Thread.MAX_PRIORITY); System.out.println("最低优先级"
* + Thread.MIN_PRIORITY); System.out.println("默认优先级" + Thread.NORM_PRIORITY);
*/
// 获取当前线程对象，获取当前线程的优先级
Thread currentThread = Thread.currentThread();
currentThread.setPriority(1);
// System.out.println(currentThread.getName() + "线程的默认优先级：" + currentThread.getPriority());
Thread t = new Thread(new MyRunnable5());
t.setPriority(10);
t.setName("t");
t.start();
// 优先级高的，只是抢到的CPU时间片相对多一些
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName() + "--->" +i);
}
}
}
class MyRunnable5 implements Runnable {
@Override
public void run() {
// 获取线程优先级
// System.out.println(Thread.currentThread().getName() + "线程的默认优先级：" + Thread.currentThread().getPriority());
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName() + "--->" +i);
}
}
}
12、ThreadTest12.java
让位，当前线程暂停，回到就绪状态，让给其他线程
静态方法：Thread.yield();
package keywords.thread多线程;
public class ThreadTest12 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable6());
t.setName("t");
t.start();
for (int i = 1; i <= 1000; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
class MyRunnable6 implements Runnable {
@Override
public void run() {
for (int i = 1; i <= 1000; i++) {
// 每100个让位一次
if(i%100==0) {
Thread.yield(); // 当前线程暂停一下，让给主线程。
}
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
13、ThreadTest13.java
package keywords.thread多线程;
public class ThreadTest13 {
public static void main(String[] args) {
System.out.println("main begin");
Thread t = new Thread(new MyRunnable7());
t.setName("t");
t.start();
// 合并线程
try {
t.join(); // t合并到当前线程中，当前线程受阻塞，t线程执行直到结束。
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("main over");
}
}
class MyRunnable7 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "--->" +i);
}
}
}
14、ThreadTest14.java
①、银行账户：Account.java
不使用线程同步机制，多线程对同一个账户进去取款，出现线程安全问题
package keywords.thread多线程;
public class Account {
private String name;
private double balance;
public Account() {
}
public Account(String name, double balance) {
this.name = name;
this.balance = balance;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
// 取款方法
public void withdraw(double money) {
// t1和t2并发这个方法……(t1和t2是两个栈,两个栈操作堆中同一个对象。)
// 取款之前的余额
double before = this.getBalance();
// 取款之后的余额
double after = before - money;
// 更新余额
// 模拟下网络延迟，一定出问题
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 思考: t1执行到这里，还没得及执行下一行代码。此时t2线程进来withdraw方法了。此时一定出问题。
this.setBalance(after);
}
}
②、AccountThread.java
package keywords.thread多线程;
public class AccountThread extends Thread {
// 两个线程必须共享同一个账户对象
private Account act;
// 通过构造方法传递过来账户对象
public AccountThread(Account act) {
this.act = act;
}
public Account getAct() {
return act;
}
public void setAct(Account act) {
this.act = act;
}
public void run() {
// run方法的执行表示取款的操作
// 假设取款5000
double money = 5000;
// 取款
act.withdraw(money);
System.out.println(Thread.currentThread().getName() + "对"
+ "账户" + act.getName() + "取款"+ money +"成功，余额：" + act.getBalance());
}
}
③、AccountTest.java
package keywords.thread多线程;
public class AccountTest {
public static void main(String[] args) {
// 创建账户对象(在创建1个)
Account act = new Account("act-001",10000);
// 创建两个线程
Thread t1 = new AccountThread(act);
Thread t2 = new AccountThread(act);
// 设置name
t1.setName("t1");
t2.setName("t2");
// 启动线程取款
t1.start();
t2.start();
}
}
④、ThreadTest14.java
守护线程——用户线程在守护线程就守护，没有用户线程了守护线程就没了。
即使守护线程的内容是个死循环也会结束。
package keywords.thread多线程;
public class ThreadTest14 {
public static void main(String[] args) {
Thread t = new BakDataThread();
t.setName("备份数据的线程");
// 启动线程之前：将线程设置为守护线程
t.setDaemon(true);
t.start();
// 主线程：主线程是用户线程
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class BakDataThread extends Thread {
public void run() {
int i = 0;
while(true) {
System.out.println(Thread.currentThread().getName() + "--->" + (++i));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
15、ThreadTest15.java
package keywords.thread多线程;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class ThreadTest15 {
public static void main(String[] args) throws ParseException {
// 创建定时器对象
Timer timer = new Timer();
// 指定定时任务
// timer.schedule(定时任务, 第一次执行时间, 间隔多久执行一次);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date firstTime = sdf.parse("2020-7-09 22:30:00");
timer.schedule(new LogTimerTask(), firstTime, 1000 * 10);
/* 也可以使用匿名内部类的方式实现
timer.schedule(new TimerTask() {
@Override
public void run() {
}
}, 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 + ":成功完成了一次数据备份！");
}
}
16、ThreadTest16.java
package keywords.thread多线程;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;// JUC包下的，属于java的并发包，老JDK中没有这个包。新特性。
public class ThreadTest16 {
public static void main(String[] args) throws Exception {
// 第一步：创建一个“未来任务类”对象
// 参数非常重要，需要给一个Callbale接口实现类对象。
FutureTask task = new FutureTask(new 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）
}
});
// 创建线程对象
Thread t = new Thread(task);
// 启动线程
t.start();
// 在这里是main方法，在主线程怎么获取t线程的返回结果？
Object obj = task.get();
System.out.println("线程执行结果： " + obj);
/* 思考一下：
* 这个get()方法的执行会不会导致main方法的阻塞？
* --- 会,故线程的第三种实现方式效率较低。但是可以获取到线程的执行结果
*
* main方法这里的程序要想执行必须等待get()方法的结束
* 而get()方法可能需要很久。因为get()方法是为了另一个线程的执行结果
* 另一个线程的执行是需要时间的。
*/
System.out.println("main over");
}
}
17、ThreadTest17.java
1、使用wait和notify方法实现“生产者和消费者模式”
2、什么是“生产者和消费者模式”？
生产线程负责生产，消费线程负责消费。
生产线程和消费线程要达到均衡。
这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法。
3、wait和notify方法不是线程对象的方法，是普通java对象都有的方法。
4、wait方法和notify方法简历在线程同步的基础之上。因为多线程要同时操作一个仓库。
有线程安全问题。
5、wait方法的作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且释放t线程之前占有的o对象的锁。
6、notify()方法作用：o.notify()让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁。
7、模拟这样一个需求：仓库我们使用List集合。
List集合中假设只能存储1个元素。 1个元素就表示仓库满了。
如果List集合中元素个数是0，就表示仓库空了。
保证List集合中永远都是最多存储一个元素。
必须做到这种效果：生产1个消费1个。
package keywords.thread多线程;
import java.util.ArrayList;
import java.util.List;
public class ThreadTest17 {
public static void main(String[] args) {
// 创建1个仓库对象，共享的。
List<Object> list = new ArrayList<Object>();
// 创建两个线程对象
// 生产者线程
Thread t1 = new Thread(new Producer(list));
// 消费者线程
Thread t2 = new Thread(new Consumer(list));
t1.setName("生产者线程");
t2.setName("消费者线程");
t1.start();
t2.start();
}
}
// 生产线程
class Producer implements Runnable {
// 仓库
private List<Object> list;
public Producer(List<Object> list) {
this.list = list;
}
@Override
public void run() {
// 一直生产（使用死循环模拟一直生产）
while(true) {
System.out.println("Produce_run");
// 给仓库对象list加锁
synchronized (list) {
if(list.size() > 0) { // 大于0，说明仓库里已经有1个元素了。
try {
list.wait(); // 当前线程进入等待状态，并且释放list集合的锁。
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 程序执行到这里说明仓库是空的，可以生产
Object obj = new Object();
list.add(obj);
System.out.println(Thread.currentThread().getName() + "--->" + obj);
// 唤醒消费者消费
list.notifyAll();
}
}
}
}
// 消费线程
class Consumer implements Runnable {
// 仓库
private List<Object> list;
public Consumer(List<Object> list) {
this.list = list;
}
@Override
public void run() {
// 一直消费
while(true) {
System.out.println("Consumer_run");
synchronized (list) {
if(list.size() == 0) {
// 仓库已经空了
// 消费者线程等待
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 程序能够执行到此处说明仓库里有数据，进行消费
Object obj = list.remove(0);
System.out.println(Thread.currentThread().getName() + "--->" + obj);
// 唤醒生产者生产
list.notifyAll();
}
}
}
}