}

public static voidmain(String... inheriting) {
   System.out.println(Thread.currentThread().getName() + " isrunning");

    newInheritingThread("inheritingThread").start();
}

@Override
public void run() {
    System.out.println(Thread.currentThread().getName()+ " is running");
}

}

![image](https://s2.51cto.com/images/20210923/1632327827508022.jpg)

当我们start()使用new 调用方法时inheritingThread()，将run()执行方法中的逻辑。

我们还在Thread类构造函数中传递第二个线程的名称，因此输出将是：

main is running.
inheritingThread is running.

**并发多线程处理：Runnable接口**

![image](https://s2.51cto.com/images/20210923/1632327828496631.jpg)

Runnable在Thread构造函数内部传递会导致更少的耦合和更大的灵活性。传递之后Runnable，我们可以start()像上一个示例中那样调用方法：

public class RunnableThread implements Runnable {

public static voidmain(String... runnableThread) {
   System.out.println(Thread.currentThread().getName());

    new Thread(new RunnableThread()).start();
}

@Override
public void run() {
   System.out.println(Thread.currentThread().getName());
}

**非守护进程vs守护进程线程**

**在执行方面，有两种类型的线程：**

- 执行非守护程序线程会一直到结束。主线程本身就是非守护程序线程的一个很好的例子。main()除非System.exit()强制程序完成，否则代码输入将始终执行到最后。

- 一个守护线程是相反的，是一个不需要一直执行到结束的处理程序。

请记住规则：如果封闭的非守护程序线程在守护程序线程之前结束，则守护程序线程将在结束之前执行。为了更好地理解守护进程和非守护进程线程的关系，请参考以下示例：

import java.util.stream.IntStream;

public class NonDaemonAndDaemonThread {

public static voidmain(String... nonDaemonAndDaemon) throws                        InterruptedException {
   System.out.println("Starting the execution in the Thread "+      Thread.currentThread().getName());

    Thread daemonThread = newThread(() ->     IntStream.rangeClosed(1, 100000)
           .forEach(System.out::println));

   daemonThread.setDaemon(true);
    daemonThread.start();

    Thread.sleep(10);

    System.out.println("Endof the execution in the Thread " +   
                                      Thread.currentThread().getName());
}

}

在这个例子中，我使用了守护程序线程来声明1到100,000的范围，迭代所有这些，然后打印。

![](https://s2.51cto.com/images/20210923/1632327828403238.jpg)

输出将按如下方式进行：

1/. 在主线程中开始执行。

2/. 打印数字从1到100,000。

3/. 主线程中的执行结束，很可能在迭代到100,000之前完成。

最终输出将取决于你的JVM实现。

![](https://s2.51cto.com/images/20210923/1632327828605805.jpg)

**线程优先级和JVM**

可以使用该setPriority方法确定线程执行的优先级，但是如何处理它取决于JVM实现。Linux，MacOS和Windows都有不同的JVM实现，每个都将根据自己的默认值处理线程优先级。

但是，你设置的线程优先级确实会影响线程调用的顺序。在Thread类上的三个常数是：

/**

• The minimum priority that athread can have.
  */
  public static final intMIN_PRIORITY = 1;

  /**

  • The default priority that isassigned to a thread.
    */
    public static final intNORM_PRIORITY = 5;

  /**

  • The maximum priority that athread can have.
    */
    public static final intMAX_PRIORITY = 10;

尝试对以下代码运行一些测试，以查看最终的执行优先级

public class ThreadPriority {

    public static voidmain(String... threadPriority) {
        Thread moeThread = newThread(() -> System.out.println("Moe"));
        Thread barneyThread = newThread(() -> System.out.println("Barney"));
        Thread homerThread = newThread(() -> System.out.println("Homer"));

       moeThread.setPriority(Thread.MAX_PRIORITY);
       barneyThread.setPriority(Thread.NORM_PRIORITY);
       homerThread.setPriority(Thread.MIN_PRIORITY);

        homerThread.start();
        barneyThread.start();
        moeThread.start();
    }
}

即使我们设置moeThread为MAX_PRIORITY，我们也不能指望首先执行此线程。相反，执行顺序将是随机的。

但是，使用常量有一个问题：如果传递的优先级数字不在1到10的范围内，setPriority（）方法将引发IllegalArgumentException。所以我们可以使用枚举来解决这个问题。使用枚举Enums既简化了代码，又能够更好地控制代码的执行。

public class ThreadChallenge {
    private static int line = 10;

    public static voidmain(String... doYourBest) {
        newtool("Car").start();

        tool Bike = newtool("Bike");
       Bike.setPriority(Thread.MAX_PRIORITY);
        Bike.setDaemon(false);
        Bike.start();

        tool Train = newtool("Train");
       Train.setPriority(Thread.MIN_PRIORITY);
        Train.start();
    }

    static class tool extends Thread{
        tool(String Name) {super(Name); }

        @Override public void run(){
            line++;
            if (line == 13) {
               System.out.println(this.getName());
            }
        }
    }
}

Kafka进阶篇知识点

Kafka高级篇知识点

44个Kafka知识点（基础+进阶+高级）解析如下

由于篇幅有限，小编已将上面介绍的《Kafka源码解析与实战》、Kafka面试专题解析、复习学习必备44个Kafka知识点（基础+进阶+高级）都整理成册，全部都是PDF文档

CodeChina开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频】