【Java中Tread和Runnable创建新的线程的使用方法】

喜欢博主的关注一下，不喜欢的再看看。٩( •̀㉨•́ )و get！

---

前言

什么是线程？

线程（Thread）是操作系统能够进行运算调度的最小单位，它被包含在进程中，是进程中的实际执行单位。与进程不同的是，同一进程中的线程共享相同的内存空间，可以访问进程中的共享数据，线程的切换开销比进程小，因此线程通常比进程更高效。线程也被称为轻量级进程。

线程可以并发执行，一个进程中可以包含多个并发执行的线程，每个线程可以独立地执行不同的任务。在多核处理器的情况下，多个线程可以被分配到不同的核心上同时执行，从而提高处理器的利用率和程序执行的效率。

---

创建线程的不同方式

一、继承Thread

//自定义类MyThread
class MyThread extends Thread {//继承Thread重写run()
    @Override
    public void run() {//线程入口
        while (true) {
            System.out.println("Hello MyThread!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();//会创建新的线程，执行run()
        //t.run();//同样会执行run方法，但是不会创建新的线程

        while (true) {//main线程执行的任务
            System.out.println("Hello main!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

---

二、实现Runnable

//自定义MyRunnable类
class MyRunnable implements Runnable {//实现Runnable接口,重写run()
    @Override
    public void run() {
        while (true) {
            System.out.println("Hello t!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
    	//Runnable不能直接使用
        MyRunnable runnable = new MyRunnable();
        //需要将runnable放入Thread中才能调用
        Thread t = new Thread(runnable);
        t.start();
    }
}

---

三、匿名内部类

1. 扩展Thread类

public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread() {//匿名内部类，扩展Thread
          @Override
          public void run() {
              while (true) {
                  System.out.println("Hello t");
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }
        };

        t.start();

        while (true) {
            System.out.println("Hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

---

2. 扩展Runnable类

public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {//匿名内部类，扩展Runnable
            @Override
            public void run() {
                while (true) {
                    System.out.println("Hello t");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        t.start();

        while (true) {
            System.out.println("Hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

---

四、lambda表达式写法

lambda实际也是匿名内部类的一种简洁写法

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {//lambda表达式写法,推荐写法
        //{}内就是run()方法内部
            while (true) {
                System.out.println("Hello t");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t.start();

        while (true) {
            System.out.println("Hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

---

五、Java 的线程 和 操作系统线程 的关系

• Java 的线程是建立在操作系统线程之上的。Java 程序通过 JVM（Java 虚拟机）来运行，JVM 将 Java线程映射到操作系统线程上，以便在操作系统上调度和执行。
• 操作系统线程是由操作系统负责管理的，因此 Java 程序需要在操作系统上获得足够的权限才能访问和操作这些线程。
• Java 线程管理和操作系统线程管理的主要区别在于，Java 线程的创建、销毁和调度是由 JVM 来完成的，而不是由操作系统来完成的。
• Java 线程的资源消耗相对较小，因为 Java 线程的创建和销毁是由 JVM 来完成的，而不是由操作系统来完成的（操作系用的调用会消耗更多的资源），这也就意味着 Java 应用程序可以同时运行更多的线程，而不需要过多地消耗系统资源。

简单来说

1. 线程是操作系统中的概念. 操作系统内核实现了线程这样的机制, 并且对用户层提供了一些 API 供用户使用(例如 Linux 的 pthread 库)

2. Java 标准库中 Thread 类可以视为是对操作系统提供的 API 进行了进一步的抽象和封装