多线程的五种“打开”方式

1 概念

1.1 线程是什么？？

线程（Thread）是计算机科学中的一个基本概念，它是进程（Process）中的一个执行单元，负责执行程序的指令序列。线程是操作系统能够进行调度和执行的最小单位。在多任务操作系统中，多个线程可以在同一个进程内并发执行，共享进程的资源。

{

假设你正在厨房中准备晚餐，这个过程中有多个线程在运行，每个线程代表一个不同的烹饪任务。这些线程可以同时执行，以加速整个烹饪过程，就像多线程在计算机程序中一样。

主厨线程：这个线程负责协调整个烹饪过程。主厨线程制定了食谱和指导其他线程如何协同工作。

切菜线程：这个线程负责将食材切成适当的大小和形状。它可以在切菜板上进行多个切割任务，以提高效率。

炉灶线程：这个线程负责在炉灶上烹饪不同的菜肴。例如，一个线程可以煮汤，另一个线程可以煎肉，它们可以同时工作，以节省时间。

烤箱线程：如果你需要烤一道菜，那么烤箱线程可以负责在烤箱中烘烤食物，同时其他线程继续处理其他任务。

洗碗线程：一旦完成烹饪，就有一个线程负责洗碗和清理厨房。这个线程可以与其他线程并发运行，以确保整个晚餐流程的顺利结束。

在这个例子中，每个线程都代表一个不同的烹饪任务，它们可以并行工作，以提高烹饪效率，就像多线程在计算机程序中允许不同任务并发执行一样

}

1.2 为什么要使用线程？？

1 “并发编程”成为“刚需”

单核CPU的发展遇到了瓶颈，想要提高算力，就需要多核CPU。而并发编程能够充分利用多核CPU资源；

有些任务场景需要“等待IO”，为了让等待的时间去做一些其他工作，也需要使用到并发编程。

2. 虽然进程也能够实现并发编程，但是线程比进程更加轻量级。

创建线程比创建进程更快.
销毁线程比销毁进程更快.
调度线程比调度进程更快.

1.3 进程和线程的区别？？

进程是包含线程的。每个进程至少有一个线程的存在，也就是主线程；
进程和线程之间不共享内存空间。同一个进程的线程之间共享同一内存空间；
进程是系统分配资源的最小单位，线程是操作系统调度的最小单位；
进程是相互独立的，一个进程的崩溃通常不会影响其他进程。线程之间更密切相关，一个线程的错误可能会影响到同一进程中的其他线程。
创建和销毁进程通常比线程昂贵，因为进程需要分配和释放独立的内存空间和资源。线程的创建和销毁通常更快，因为它们共享进程的资源，不需要分配独立的内存空间。

1.4 Java的线程和操作系统的线程的区别？？

线程是操作系统中的概念. 操作系统内核实现了线程这样的机制, 并且对用户层提供了一些 API 供用户使用(例如 Linux 的 pthread 库).
Java 标准库中 Thread 类可以视为是对操作系统提供的 API 进行了进一步的抽象和封装.

2 感受多线程代码

多线程和普通程序最大的区别就是每个线程都是独立的执行流多线程之间是并发执行的。

public class ThreadDemo {
    private static class MyThread extends Thread{
        @Override
        public void run() {
            Random random = new Random();
            while (true){
                // 打印主线程名称
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(random.nextInt(10));//随机停止运行0-9秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        //启动并创建线程工作
        t1.start();
        t2.start();
        t3.start();

        //主线程工作
        Random random = new Random();
        while (true){
            // 打印主线程名称
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(random.nextInt(10));//随机停止运行0-9秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

结果：

我们可以使用JDK提供的jconsole命令观察线程（在jdk的bin目录下面）

3 创建线程的“五种”方式

方法1 继承Thread类

public class ThreadDemo1 {

    static class MyThread extends Thread{
        //重写run方法  run描述该线程要干的活是什么
        @Override
        public void run() {
            System.out.println("我是一个线程 hello thread!");
        }
        //run方法执行完毕后 新的这个线程就会被销毁
    }

    public static void main(String[] args) {
        Thread thread = new MyThread();//thread类不需要任何包？？为什么还有哪些我们见过的 出现这种情况 java.lang包下面的是不用导包的 比如string stirngbuilder
        thread.start();//线程中的启动方法 start创建了一个新线程 有新线程来执行run方法
    }
}

方法2 实现Runnable 接口

// Runnable 作用就是描述一个“要执行的任务” run方法就是任务的执行细节
class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("hello thread-runnable");
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {
        // new Runnable就是描述一个任务
        MyRunnable runnable = new MyRunnable();
        //然后将这个任务交给线程来执行
        Thread thread = new Thread(runnable);
        thread.start();
        thread.run();
        /*
        * thread.run()是在当前线程中执行线程的任务，没有创建新的线程，不实现并发。
        thread.start()创建一个新的线程，并在新线程中执行线程的任务，实现了多线程并发。通常应该使用thread.start()来启动线程*/
    }
}

首先对比一下上面两种方法：

继承 Thread 类, 直接使用 this 就表示当前线程对象的引用.

实现 Runnable 接口, this 表示的是 MyRunnable 的引用. 需要使用 Thread.currentThread()

后面的方法都是前两者的“变形”：

方法3 匿名内部类创建 Thread 子类对象

//使用匿名内部类来实现线程
public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                System.out.println("匿名内部类实现thread");
            }
        };
        t.start();
    }
}

方法4 匿名内部类创建 Runnable 子类对象

//使用匿名内部类
public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("实现runnable-匿名内部类");
            }
        });
        t.start();
    }
}

方法5 lambda 表达式创建 Runnable 子类对象

//lambda
public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("hello thread");
        });
        t.start();
    }
}