class Mythread extends Thread{
    @Override
    public void run() {
        System.out.println("the first thread");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();
    }
}

☀️具体分析：

@Override
    public void run() {
        System.out.println("the first thread");
    }

重写了Thread里的run方法，里面的代码就表示这个线程具体要干什么，这里相当于安排任务，病是不是说这里的代码一写出来就可以执行这个线程

thread.start();

start方法是真正的创建出线程的方法，只有调用了start方法，线程才能被创建出来，上面重写的run方法也才能被执行

💗6.五种创建线程的方法

🐔创建一个子类继承Thread

class Mythread extends Thread{
    @Override
    public void run() {
        System.out.println("the first thread");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();
    }
}

🐛创建一个类实现Runnable

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("my second thread");
    }
}

public class TestDemo2 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

🐞使用匿名内部类

public class TestDemo3 {
    public static void main(String[] args) {
        Thread thread = new Thread(){
            @Override
            public void run() {
                System.out.println("my third thread");
            }
        };
        thread.start();
    }
}

🐠使用匿名内部类

public class TestDemo3 {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("my fourth thread");
            }
        });
        thread.start();
    }
}

🐏使用lambda表达式

public class TestDemo3 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("my fifth thread");
        });
        thread.start();
    }
}

相比较以上四种方式，lambda表达式可能会比较难理解一点，但却实最简洁的一种写法

💘7.多线程的优势

创建一个变量让他们分别自增10_0000_0000次，分别使用串行执行和并发执行，分别使用前后的时间戳来表示他们的时间

public class Demo4 {

    public static final long count = 1000000000;

    /**
     * 串行形式
     */
    public static void serial(){
        long start = System.currentTimeMillis();
        long a = 0;
        for(int i = 0; i<count;i++){
            a++;
        }
        long b = 0;
        for(int i = 0;i<count;i++){
            b++;
        }
        long end = System.currentTimeMillis();
        System.out.println((end - start)+ "ms");
    }

    /**
     * 并发执行
     */
    public static void concurrency() throws InterruptedException {
        long start = System.currentTimeMillis();
        Thread thread1 = new Thread(() -> {
            long a = 0;
            for (int i = 0; i < count; i++) {
                a++;
            }

        });
        Thread thread2 = new Thread(() ->{
            long b = 0;
            for (int i = 0; i < count; i++) {
                b++;
            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        long end = System.currentTimeMillis();
        System.out.println((end - start) + "ms");

    }

这里要注意的一点就是 .join() 方法，这个方法的意思是等待该线程执行完

可以很清楚的看到并发执行的速度要大于串发执行的速度，但是多线程并不是万能的，多线程适合于CPU密集型的程序，程序要进行大量的计算，使用多线程可以更充分的利用CPU的多核资源

💘8.Thread类及其常见方法

Thread类是JVM用来管理线程的一个类，换句话说，每个线程都有一个唯一的Thread对象与之相关联。

根据上述例子，每个执行流，也需要有一个对象来描述，而Thread类的对象就是用来藐视一个线程执行流的，JVM会将这些Thread对象组织起来，用于线程调度，线程管理

⚡8.1.Thread的常见构造方法

⚡8.2.Thread常见属性

♠️ id ：id是线程的唯一标识，不同的线程不能有相同的id

♠️名称：名称是帮助程序员调试用的比如使用 jconsole

JVM调优之JConsole和JVisualVM工具使用_执笔记忆的空白的博客-CSDN博客_jconsole jvisualvm

♠️状态：状态表示线程当前所处的一个情况

♦️优先级：优先级高的线程理论上来说更容易被调度到

♦️是否是后台进程：关于后台线程，需要记住一点：JVM会在一个进程的所有非后台线程结束后，才会结束运行

♦️是否存活：是否存活，即简单的理解，为 run 方法是否运行结束了

♦️是否被中断：字面意思

强调两个方法：

①isDaemon()：如果线程是后台进程，就不影响进程退出，如果线程是前台线程，就会影响到进程的退出。

例如：如果创建的thread1线程和thread2线程都是前台线程，即使main方法执行完毕，进程也不能退出，得等thread1和thread2都执行完，整个进程才能退出，如果两个都是后台线程，则main执行完毕后，整个进程能直接退出

②isAlive()：操作系统中对应的线程是否正在运行。Thread thread 对象的生命周期和内核中对应的线程，生命周期并不完全一致，创建出threa对象之后，在调用start之前，系统中没有对应线程的，在run方法执行完之后，系统中的线程就销毁了，但是thread这个对象可能还在，通过isAlive就能判定当前系统线程的运行情况

如果调用start之后，run执行完之前，isAlive就是返回true

如果调用start之前，run执行完之后，isAlive就返回false

💘9.Thread常用的一些方法

public class TestDemo3 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("my fifth thread");
        });
//        thread.start();
        thread.run();
    }
}

执行结果：my fifth thread

public class TestDemo3 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("my fifth thread");
        });
        thread.start();
//        thread.run();
    }
}

执行结果：my fifth thread

可以看到，两段代码执行的结果都是一样的，那么这两个有什么区别吗？

💊run 方法只是一个普通的方法，单纯的描述了线程里面的内容，在main里调用run方法，就是单纯的串行执行代码，start则是一个特殊的方法，内部会在系统中创建线程

💘10.中断线程

public class TestDemo3 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while(true){
                System.out.println("my  thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
    }
}

以上的线程会不断的打印 my thread ，并不会停下来，那么如何能够终止一个线程呢？

①使用标记位

public class TestDemo3 {
    private static boolean isQuit = false;

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!isQuit) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        isQuit = true;
        System.out.println("终止 t 线程!");
    }
}

②使用Thread类自带的标记位

public class TestDemo4 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("my thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        thread.interrupt();
    }
}

但是使用Thread类自带的标记位会出现以下的情况

这是为啥呢，难道出错了 ❔❔❔

调用这个方法可能会产生两种情况：

①如果thread 线程处于就绪状态，则设置线程的标志位会变成true

②如果thread线程处于阻塞状态（例如sleep休眠），就会触发一个InterruptException

💘11.等待一个线程 join()

多个线程之间，调度顺序是不确定的，线程之前的执行是按照调度器来安排的，这个过程可以视为“无需，随机”，这样不太好，有些时候我们需要能控制线程之间的顺序，而线程等待就是其中一种解决办法，此处的线程等待主要是控制线程结束的先后顺序

join() : 前面也是介绍了join 的使用方法，哪一个线程使用jion，哪一个线程就会阻塞等待，直到对应的线程执行完毕，即run方法执行完毕

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() ->{
            while (true) {
                System.out.println("my thred");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        thread.join();

        System.out.println("my main");

    }
}

根据上述代码，首先，调用这个方法的线程是main线程，针对thread这个线程对象调用的，意思是让main等待thread，调用join方法之后，main线程就会进入阻塞状态，意思是暂时无法被调度到CPU上执行，直到thread这个线程的run跑完之后main这个线程才开始运行

join这个操作默认情况下是死等 💩

当然join也提供了另外一个版本，也就是可以执行等待时间，设置最长等待多长时间，如果超过了等待时间，那么程序就直接扯，开始下一个线程的执行，对于以后的开发中，一般用的都是第二个版本

💘12.获取当前线程的引用

💩💩💩 这个方法前面也是用过

Thread.currentThread()，能够获取得到当前线程引用（Thread实例的引用），哪个线程调用的这个currentThread，那个线程就能获取到当前线程的实例

1）

public class Test {
    public static void main(String[] args)  {
        Thread thread = new Thread(){
            @Override
            public void run() {
                System.out.println(this.getName());
            }
        };
        thread.start();
    }
}

这段代码是通过继承Thread的方式来创建线程，此时在run方法中，直接通过this拿到的就是Thread的实例

2）

public class Test {
    public static void main(String[] args)  {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(this.getName()); //这里是错误的，代码不能执行
            }
        });
        thread.start();
    }
}

此处的this并不是指向Thread类型，而是指向Runnable，而Runnable只是一个单纯的任务，没有name属性

正确的用法：

public class Test {
    public static void main(String[] args)  {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()); //这里是错误的，代码不能执行
            }
        });
        thread.start();
    }
}

通过Thread.currentThread获取到当前线程的实例，就能获取到线程的名字了