夜光序言：
我发誓离开你我笑了，笑的眼泪都掉了。
正文：
以道御术 / 以术识道
定义：守护线程--也称“服务线程”，在没有用户线程可服务时会自动离开。
优先级：守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。
设置：通过setDaemon(true)来设置线程为“守护线程”；将一个用户线程设置为守护线程的方式是在 线程对象创建 之前 用线程对象的setDaemon方法。
example: 垃圾回收线程就是一个经典的守护线程，当我们的程序中不再有任何运行的Thread,程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是JVM上仅剩的线程时，垃圾回收线程会自动离开。它始终在低级别的状态中运行，用于
实时监控和管理系统中的可回收资源。
生命周期：守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。也就是说守护线程不依赖于终端，但是依赖于系统，与系统“同生共死”。那Java的守护线程是什么样子的呢。当JVM中所有的线程都是守护线程的时候，JVM就可以退出了；如果还有一个或以上的非守护线程则JVM不会退出。
需要注意：
(1) thread.setDaemon(true)必须在thread.start()之前设置，否则会跑出一个IllegalThreadStateException异常。
嗯唔~~
不能把正在运行的常规线程设置为守护线程。
(2) 在Daemon线程中产生的新线程也是Daemon的。
(3) 不要认为所有的应用都可以分配给Daemon来进行服务，比如读写操作或者计算逻辑。
嗯唔：
一旦所有User Thread离开了，虚拟机也就退出运行了。 大量数据还没有来得及读入或写出，计算任务也可能多次运行结果不同
所以 不要认为所有的应用都可以分配给Daemon来进行服务，比如读写操作或者计算逻辑。
package 夜光第二部分.案例1;
/*
*
* @title Demo2
* @describe
* @author hy
* @version
* @date 2019/12/19
*
*/
public class Demo2 extends Thread { //首先继承一下
public Demo2(String name) {
super(name);
}
//我们来重写一下run方法，夜光
@Override
public void run() {
while (true) {
System.out.println(getName() + "线程执行了~~");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Demo2 d1 = new Demo2("炎帝");
Demo2 d2 = new Demo2("雷帝");
d1.start();
d2.start();
//线程的中断
d1.interrupt();
}
}
package 夜光第二部分.案例1;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Demo4 implements Callable<Integer> {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Demo4 d = new Demo4();
FutureTask<Integer> task = new FutureTask<>(d); //有了任务之后
Thread t = new Thread(task);//线程
//之后就可以启动一下
t.start();
//我们还需要拿到返回结果
Integer result = task.get();
System.out.println("线程执行的结果为：" + result);
}
@Override
public Integer call() throws Exception {
System.out.println("正在进行紧张的计算~~~");
Thread.sleep(3000);
return 1;
}
}
package 夜光第二部分.案例1;
import java.util.Timer;
import java.util.TimerTask;
public class Demo5
{
public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
//实现定时任务
System.out.println("正在执行任务~~");
}
},0,1000); //延迟时间0，每隔一秒执行一次
}
}
上面这种方式有一个最大的问题不可控
package 夜光第二部分.案例1;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
public class Demo6 {
public static void main(String[] args) {
//下面这个就代表线程池
//创建带有10个的线程池
Executor threadpool = Executors.newFixedThreadPool(10);
threadpool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
}
}
package 夜光第二部分.案例1;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
public class Demo6 {
public static void main(String[] args) {
//下面这个就代表线程池
//创建带有10个的线程池
Executor threadpool = Executors.newFixedThreadPool(10);
for (int i=0;i<10;i++) { //在外层，我们写一个for循环
threadpool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
}
}
}
package 夜光第二部分.案例1;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo6 {
public static void main(String[] args) {
//下面这个就代表线程池
//创建带有10个的线程池
ExecutorService threadpool = Executors.newFixedThreadPool(10);
for (int i=0;i<10;i++) { //在外层，我们写一个for循环
threadpool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
}
threadpool.shutdown();
}
}
package 夜光第二部分.案例1;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo7 {
public static void main(String[] args) {
//下面这个就代表线程池
ExecutorService threadpool = Executors.newCachedThreadPool(); //这里，我们换一种写法
for (int i=0;i<100;i++) { //在外层，我们写一个for循环
threadpool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
}
threadpool.shutdown();
}
}
