多线程

多线程

  • 程序：指令和数据的有序集合，其本省没有任何运行的含义，是一个静态的概念。
  • 进程：是执行程序的一次执行过程，是一个动态的概念。是系统资源分配的单位
  • 线程：一个进程包含若干个线程，一个进程中至少有一个线程。线程是CPU调度和执行的单位

1.线程创建

1.1 继承Thread类

自定义线程类继承Thread类；重写run()方法，编写线程执行体；创建线程对象，调用start()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package threadDemo;
// 线程创建后不一定立即执行，由CPU调度
public class ThreadTest extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("ThreadTest--" + i);
        }
    }

    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("main--" + i);
        }
    }
}

1.2 实现Runnable接口

定义一个类实现Runnable接口，实现run()方法，编写线程执行体，创建线程对象，调用start()方法启动线程；推荐使用Runnable对象，java单继承有局限性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package threadDemo;

public class RunnableTest implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("ThreadTest--" + i);
        }
    }

    public static void main(String[] args) {
        RunnableTest runnableTest = new RunnableTest();
//        创建thread对象
        Thread thread = new Thread(runnableTest);
//        启动线程
        thread.start();

        new Thread(runnableTest).start();

        for (int i = 0; i < 100; i++) {
            System.out.println("main--" + i);
        }
    }
}

*TicketDemo

多个线程操作同一个对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package threadDemo;

public class TicketDemo implements Runnable {
    private int ticket = 10;

    @Override
    public void run() {
        while (true){
            if (ticket <= 0){
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticket-- + "张票");
        }
    }

    public static void main(String[] args) {
        Runnable runnable = new TicketDemo();

        new Thread(runnable, "小明").start();
        new Thread(runnable, "张三").start();
        new Thread(runnable, "黄牛").start();
    }
}
/*
张三拿到了第9张票
小明拿到了第8张票
黄牛拿到了第10张票
张三拿到了第7张票
小明拿到了第6张票
黄牛拿到了第5张票
黄牛拿到了第4张票
小明拿到了第3张票
张三拿到了第2张票
张三拿到了第1张票
小明拿到了第0张票 *
黄牛拿到了第-1张票 *
--------------------------
小明拿到了第8张票
黄牛拿到了第9张票
张三拿到了第10张票
黄牛拿到了第6张票
小明拿到了第5张票
张三拿到了第7张票
黄牛拿到了第4张票 *
小明拿到了第3张票
张三拿到了第4张票 *
黄牛拿到了第2张票
张三拿到了第1张票 *
小明拿到了第1张票 *
*/
//多个线程操作同一个资源，不安全，数据紊乱。

1.3 实现callable接口

  • 实现callable接口，需要返回值类型
  • 重写call方法，需要抛出异常
  • 创建目标对象
  • 创建执行服务：ExecutorService es = Executor.newFixedThreadPool(1);
  • 提交执行：Future<T> future = es.submit(t1);
  • 获取结果：T result = future.get();
  • 关闭服务：es.shutdownNow();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package threadDemo;

import java.util.concurrent.*;

public class CallableTest implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("math" + Thread.currentThread().getName());
        return (int)(Math.random()*100);
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService es =  Executors.newFixedThreadPool(3);
        Future<Integer> future = es.submit(new CallableTest());
        Future<Integer> future1 = es.submit(new CallableTest());
        Future<Integer> future2 = es.submit(new CallableTest());
        System.out.println("future:" + future.get());
        System.out.println("future1:" + future1.get());
        System.out.println("future2:" + future2.get());

        es.shutdownNow();
    }
}

2.线程状态

状态名称 说明
NEW 初始状态，线程被构建，但是还没有调用start()
RUNNABLE 运行状态，java线程将操作系统中的就绪和运行两种状态笼统的称为“运行中”
BLOCKED 阻塞状态，表示线程阻塞于锁
WAITING 等待状态，表示线程进入等待状态，进入该状态表示当前线程需要等待其他线程做出一些特定动作（通知或中断）
TIME_WAITING 超时等待状态，该状态不同于waiting，它是可以在指定的时间自行返回的
TERMINATED 终止状态，表示当前线程已经执行完毕

image-20210429222515248

image-20210429222912313

2.1线程方法

方法 说明
setPriority(int newPriority) 更改线程的优先级
static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠
void join() 等待改线程终止
static void yield() 暂停当前正在执行的线程对象，并执行其他线程
void interrupt() 中断线程（不建议使用）
boolean isAlive() 测试线程是否处于活动状态

2.2 线程终止

使用标志位，设置一个公开方法该变标志位状态，停止线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package threadDemo;

public class ThreadStop implements Runnable {
    // 设置标志位
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run...Thread:" + i++);
        }
        System.out.println(Thread.currentThread().getName() + "线程停止了");
    }
	// 修改标志位状态
    public void stop(){
        flag = !flag;
    }

    public static void main(String[] args) {
        ThreadStop ts = new ThreadStop();
        new Thread(ts,"run").start();
        for (int i = 0; i < 200; i++) {
            if (i == 100){
                ts.stop();
            }
            System.out.println("main...Thread:" + i);
        }
    }
}

2.3 线程休眠

  • sleep(long millis)指定当前线程阻塞的毫秒数；

  • sleep存在异常interruptedException；

  • sleep时间到达后线程进入就绪状态；

  • sleep可以模拟网络延时，倒计时等。

  • 每一个对象都有一个锁，sleep不会释放锁；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package threadDemo;

import java.text.SimpleDateFormat;
import java.util.Date;

public class ThreadSleep {
    public static void main(String[] args) {
        // 当前时间
        Date startTime = new Date(System.currentTimeMillis());
        // 结束时间
        Date endTime = new Date(System.currentTimeMillis() + 6000);
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
            startTime = new Date(System.currentTimeMillis());
            System.out.println(startTime);
            System.out.println(endTime);
            
            // 当前时间大于结束时间时，结束循环
            if (startTime.compareTo(endTime) == 1){
                break;
            }
        }
    }
}

2.4 线程礼让

  • 礼让线程，让当钱正在执行的 线程暂停，但不阻塞；
  • 将线程从运行状态转为就绪状态
  • 让CPU重新调度，礼让不一定成功
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package threadDemo;
// 礼让不一定成功
public class ThreadYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName() + "线程结束执行");
    }

    public static void main(String[] args) {
        new Thread(new ThreadYield(), "a").start();
        new Thread(new ThreadYield(), "b").start();
    }
}
/*
a线程开始执行
b线程开始执行
a线程结束执行
b线程结束执行
--------------------
b线程开始执行
a线程开始执行
b线程结束执行
a线程结束执行
*/

2.5 join

join合并线程，只有此线程执行完成后，再执行其他线程，其他线程阻塞

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package threadDemo;

public class ThreadJoin implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("run..." + i);
        }
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new ThreadJoin());
        thread.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("main..." + i);
            if (i == 100){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.6 查看线程状态

Thread.state

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package threadDemo;

public class ThreadState {
    public static void main(String[] args) {
        /*Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("执行完成");
            }
        });*/
//        lambda
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("执行完成");
        });

//        查看线程状态
        Thread.State state = thread.getState();
        System.out.println(state);

//        启动线程
        thread.start();
        System.out.println("启动线程");
//        查看线程状态
        state = thread.getState();
        System.out.println(state);

        while ((state = thread.getState()) != Thread.State.TERMINATED) {
            try {
//                避免执行太快
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
//            state = thread.getState();
            System.out.println(state);
        }
//      查看线程执行完后状态
        state = thread.getState();
        System.out.println(state);
    }
}

3.线程优先级

  • java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
  • 线程的优先级用数字表示，范围从1~10
    • Thread.MIN_PRIORITY = 1;
    • Thread.MAX_PRIORITY = 10;
    • Thread.NORM_PRIORITY = 5;
  • 使用getPriority()获取 setPriority(int xxx)修改优先级

优先级低只意味着获得调度的概率低，并不是优先级低就不会被调用，都是看CPU的调度

4.守护（daemon）线程

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕

后台记录操作日志、监控内存、垃圾回收等待..

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package threadDemo;

public class DaemonThread {
    public static void main(String[] args) {
        /*
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                    System.out.println("Thread..." + i);
            }
        });
        thread.start();
        */
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("Thread..." + i);
            }
        }).start();

        Thread daemonThread = new Thread(() -> {
            while (true) {
                System.out.println("daemonThread...");
            }
        });
//        设置守护线程
        daemonThread.setDaemon(true);
        daemonThread.start();
    }
}

5.线程同步

并发：多个线程操作同一个资源

线程同步：一种等待机制，多个需要同时访问此对象的线程进入对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

  • 为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的锁，独占资源，其他线程必须等待使用后释放锁。存在以下问题：
    • 一个线程持有锁会导致其他所有需要此锁的线程挂起
    • 在多线程竞争下，加锁和释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
    • 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题；

买票案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package threadDemo;
// 出现重复的票和负数票
public class UnsafeTicket implements Runnable{
    private int ticket = 10;
    private boolean flag = true;
    @Override
    public void run() {
        while (flag){
            buy();
        }
    }
    private void buy(){
        if (ticket <= 0){
            flag = false;
        }else {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":买到第" + ticket-- + "张票");
        }
    }
    public static void main(String[] args) {
        UnsafeTicket ticket = new UnsafeTicket();
        new Thread(ticket,"12306").start();
        new Thread(ticket,"携程").start();
        new Thread(ticket,"黄牛").start();
    }
}
/*
黄牛:买到第10张票
12306:买到第8张票
携程:买到第9张票
携程:买到第6张票
黄牛:买到第5张票
12306:买到第7张票
12306:买到第4张票
黄牛:买到第3张票
携程:买到第2张票
携程:买到第1张票
黄牛:买到第0张票
12306:买到第-1张票
*/

解决方法：使用同步方法，使用synchronized关键字修饰方法和块；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package threadDemo;

public class UnsafeTicket implements Runnable{
    private int ticket = 10;
    private boolean flag = true;
    @Override
    public void run() {
        while (flag){
            buy();
        }
    }

    private synchronized void buy(){
        if (ticket <= 0){
            flag = false;
        }else {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":买到第" + ticket-- + "张票");
        }
    }

    public static void main(String[] args) {
        UnsafeTicket ticket = new UnsafeTicket();
        new Thread(ticket,"12306").start();
        new Thread(ticket,"携程").start();
        new Thread(ticket,"黄牛").start();
    }
}

synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。（缺陷：若将一个大的方法使用synchronized修饰会影响效率）

方法里需要修改的内容才需要加锁，避免过多浪费资源。

同步块：synchronized(obj){}

  • obj称为同步监视器

    • obj可以是任何对象，最好使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器，同步方法的同步监视器就是this，就是对象本身或者是class

  • 同步监视器的执行过程

    • 第一个线程访问，锁定同步监视器，执行其中代码。
    • 第二个线程访问，发现同步监视器被锁定，无法访问。
    • 第一个线程访问完毕，释放同步监视器。
    • 第二个线程访问，锁定同步监视器并访问，访问完毕后释放同步监视器。

6.死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止执行的情况；某一个同步块同时拥有“两个以上对象的锁”时，就可以会发生“死锁”的问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package threadDemo;

public class DeadLock implements Runnable{
    boolean flag;

    public DeadLock(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        try {
            makeUP();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void makeUP() throws InterruptedException {
        if (flag){
            synchronized (Sources_1.class){

                System.out.println(Thread.currentThread().getName() + "获取到Sources_1");
                Thread.sleep(2000);
                synchronized (Sources_2.class){
                    System.out.println(Thread.currentThread().getName() + "获取到Sources_2");
                }
            }
        }else {
            synchronized (Sources_2.class){
                System.out.println(Thread.currentThread().getName() + "获取到Sources_2");
                Thread.sleep(2000);
                synchronized (Sources_1.class){
                    System.out.println(Thread.currentThread().getName() + "获取到Sources_1");
                }
            }
        }
    }

    public static void main(String[] args) {
        new Thread(new DeadLock(true),"Thread_1").start();
        new Thread(new DeadLock(false),"Thread_2").start();
    }
}

class Sources_1{}
class Sources_2{}

产生死锁的必要条件：

  • 互斥条件：一个资源每次只能被一个进程使用。
  • 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
  • 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
  • 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

7.lock（锁）

  • 通过显示定义同步锁对象来实现同步，同步锁使用lock对象充当；
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
  • ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReenTrantLock，可以显式加锁、释放锁。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package threadDemo;

import java.util.concurrent.locks.ReentrantLock;

public class ThreadLock implements Runnable {
    int ticket = 10;
    boolean flag = true;
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (flag) {
            try {
                lock.lock();
            buy();
            }finally {
                lock.unlock();
            }
        }
    }

    private void buy() {
            if (ticket <= 0) {
                flag = false;
            } else {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":" + ticket--);
            }
    }

    public static void main(String[] args) {
        ThreadLock lock = new ThreadLock();
        new Thread(lock).start();
        new Thread(lock).start();
        new Thread(lock).start();
    }
}

synchronized与lock对比：

  • lock是显式锁（需要手动开启和关闭锁），synchronized是隐式锁，出了作用域自动释放。
  • lock只有代码块锁，synchronized有代码块锁和方法锁
  • 使用lock锁，jvm将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性。
  • 优先使用顺序：lock > 同步代码块（已经进入方法体，分配了相应资源）> 同步方法（在方法体外）

8.线程协作

生产者消费者问题：生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。

  • 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，有需要马上通知消费者消费。
  • 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品，以供消费。
  • 在生产者消费者问题中，仅有synchronized是不够的；
    • synchronized可阻止并发更新同一个共享资源，实现同步
    • synchronized不能用来实现不同线程之间的消息传递（通信）

线程通信：

方法名 作用
wait() 表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout) 指定等待的毫秒数
notify() 唤醒一个处于等待状态的线程
notifyAll() 唤醒同一个对象上所有调用wait()方法的线程，优先级高的线程优先调度

均是object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IllegalMonitorStateException

管程法：

  • 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）；
  • 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）；
  • 缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区；
  • 生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
package threadDemo;

public class TestPC {
    public static void main(String[] args) {
        ProductBuffer pb = new ProductBuffer();
        new Thread(new Producer(pb)).start();
        new Thread(new Consumer(pb)).start();
    }
}

class Producer implements Runnable {
    ProductBuffer productBuffer;

    public Producer(ProductBuffer productBuffer) {
        this.productBuffer = productBuffer;
    }

    @Override
    public void run() {
        int product = 0;
        while (true){
            productBuffer.push(new Product(++product));
            System.out.println("生产者完成第" + product + "个产品");
        }
    }
}

class Consumer implements Runnable {
    ProductBuffer productBuffer;

    public Consumer(ProductBuffer productBuffer) {
        this.productBuffer = productBuffer;
    }

    @Override
    public void run() {
        while (true){
            Product pop = productBuffer.pop();
            System.out.println("消费者消费了第" + pop.id + "个产品");
        }
    }
}

class Product {
    int id;

    public Product(int id) {
        this.id = id;
    }
}

class ProductBuffer {
    Product[] products = new Product[10];
    //    计数器
    int count = 0;

    public synchronized void push(Product product) {
        if (count == products.length) {
            System.out.println("容器中有" + count + "个产品");
            System.out.println("生产者等待消费者消费");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        没有满继续添加
        products[count++] = product;
        this.notifyAll();
    }

    public synchronized Product pop() {
        if (count == 0) {
            System.out.println("消费者等待");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        没有满继续添加
        Product product = products[--count];
        this.notifyAll();

        return product;
    }

}

9.线程池

背景：经常创建和销毁、使用量特别大的资源，对性能影响很大。

思路：提前创建多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建和销毁，实现重复利用。

优点：

  • 提高响应速度（减少创建新线程的时间）

  • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）

  • 便于线程管理

    • corePoolSize：核心池大小
    • maximumPoolSize：最大线程数
    • keepAliveTime：线程没有任务时最多保持多长时间后会终止

  • 相关API：ExecutorService和Executors

  • ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

    • void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
    • <T> Future<T> submit(Callable<T> task)：执行任务，没有返回值，一般用来执行Callable
    • void shutdown()：关闭线程池

  • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池。

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家