文章看到这里，相信大家对线程已经有了扎实的认识，下面还有一些琐碎的关于线程的知识点，我将分别为大家做介绍
java语言中线程分为两大类：
一类是：用户线程
一类是：守护线程（后台线程）
其中具有代表性的就是：垃圾回收线程（守护线程）。
守护线程的特点：
一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。
注意：主线程main方法是一个用户线程。
package DeadLock;
/**
* 守护线程
*/
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 {
@Override
public void run() {
int i = 0;
//即使是死循环，但由于该线程是守护者 当用户线程结束，守护线程自动终止。
while (true) {
System.out.println(Thread.currentThread().getName() + "--->" + (++i));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
定时器的作用：
间隔特定的时间，执行特定的程序。 
package DeadLock;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class TimerTest {
public static void main(String[] args) throws ParseException {
//创建定时器对象
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("2021-11-25 23:14:00");
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 + ":成功完成一次数据备份！");
}
}
运行结果
package ThreadDemo;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* 实现线程的第三种方式：
* 实现Callable接口
*/
public class ThreadTest15 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//第一步：创建一个“未来任务类”对象
//参数非常重要 需要给一个 Callable 接口实现类对象
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;
}
});
//创建线程对象
Thread t = new Thread(task);
//启动线程
t.start();
//这里是main方法，这是在主线程中。
//在主线程中，怎么获取t线程的返回结果？
// get()方法的执行会导致“当前线程阻塞”
Object obj = task.get();
System.out.println("线程执行结果：" + obj);
//main方法这里的程序要想执行必须等待get()方法的结束
//而get()方法可能需要很久。因为get()方法是为了拿到另一个线程的执行结果
//而另一个线程的执行是需要时间的
System.out.println("hello world!");
}
}
package ThreadDemo;
import java.util.ArrayList;
import java.util.List;
/**
* 1、使用 wait 方法和 notify 方法实现“生产和消费者模式”
* 2、什么是“生产者和消费者模式”?
* 生产线程负责生产，消费线程负责消费。
* 生产线程和消费线程要达到均衡。
* 这是一种特殊的业务需求，在这种特殊的情况下需要使用 wait 方法和 notify 方法。
* <p>
* 3、wait 和 notify 方法不是线程对象的方法 ， 是普通java对象的方法。
* <p>
* 4、wait方法 和 notify方法建立在线程同步的基础之上。因为多线程要同时操作一个仓库。有线程安全问题。
* <p>
* 5、wait方法的作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁。
* <p>
* 6、notify方法作用：o.notify让正在o对象上等待的线程唤醒，只是通知，不会示范o对象之前占有的锁。
* <p>
* 7、模拟这样一个需求：
* 仓库我们采用List集合。
* List集合中假设只能存储1个元素。
* 1个元素就表示仓库满了。
* 如果List集合中元素个数是0，就表示仓库空了。
* 保证List集合中永远都是最多存储1个元素。
* <p>
* 必须做到这种效果：生产1个消费1个
*/
public class ThreadTest16 {
public static void main(String[] args) {
// 创建1个仓库对象，共享的。
List list = new ArrayList<>();
// 创建两个线程对象
// 生产者线程
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 list;
public Producer(List list) {
this.list = list;
}
@Override
public void run() {
//一直生产（使用死循环来来模拟一直生产）
while (true) {
synchronized (list) {
if (list.size() > 0) { //大于0 说明仓库中已经有有一个元素了。
try {
//当前线程进入等待状态，并且释放 list 集合的锁。
//当 list.notify(); 执行之后就会直接执行之后的代码，不会从头再来
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//程序能够执行到这里说明仓库是空的，可以生产
Object obj = new Object();
list.add(obj);
System.out.println(Thread.currentThread().getName() + "--->" + obj);
//唤醒消费者进行消费
list.notify();
}
}
}
}
//消费线程
class Consumer implements Runnable {
//仓库
private List list;
public Consumer(List list) {
this.list = list;
}
@Override
public void run() {
//一直消费
while (true) {
synchronized (list) {
if (list.size() == 0) { //等于0 说明仓库中已经空了。
try {
//当前线程进入等待状态，并且释放 list 集合的锁。
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//程序能够执行到此处说明仓库中有数据，可以消费
Object obj = list.remove(0);
System.out.println(Thread.currentThread().getName() + "--->" + obj);
//唤醒生产者
list.notify();
}
}
}
}