目录：

前言

1.进程与线程的区别？

2.进程是操作系统进行资源分配的基本单位，而操作系统是以线程为单位进行调度的。

3. Java操作多线程，依赖最核心的类Thread。

4.关于start和run的区别？

5.使用JDK自带的工具jconsole来查看当前java进程中的所有线程。

Java中创建线程的五种写法

1.继承Thread，重写run

2.实现Runnable接口

3.使用匿名内部类，继承Thread

4.使用匿名内部类，实现Runable

5.使用Lambda表达式

---

---

前言

进程与线程的区别？

（参考之前写的一篇博客：多进程编程 VS 多线程编程_crazy_xieyi的博客-CSDN博客_多进程编程和多线程编程创建线程/销毁线程比创建进程/销毁进程更加高效和轻量。所以，一般情况下，会使用多线程来进行开发。但是，多进程也有它自己独特的优势，进程的“独立性”更好。进程要比线程来的更加稳定一点。虽然进程没有线程那么高效，但是它的独立性带来的稳定是非常关键的，在某些场景下必须使用多进程编程。https://blog.csdn.net/crazy_xieyi/article/details/127427551?spm=1001.2014.3001.5501%EF%BC%89

因为CPU现在进入了多核心的时代，要想进一步提高程序的执行速度，就需要充分的利用CPU的多核资源。引入进程这个概念，最主要的目的就是为了解决并发编程这样的问题。其实多进程编程已经可以解决并发编程的问题了，但是进程太重了，在资源分配和回收上的消耗资源多且速度比较慢，创建销毁调度进程的开销比较大。这个时候就引入了线程的概念，线程也可以叫做“轻量级进程”，在解决并发编程的前提下，让创建销毁调度的速度更快一些。因为线程是把资源的申请和释放的操作给省略了，所以更轻更快。

进程和线程的关系：进程包含线程，一个进程可以包含一个线程，也可以包含多个线程。只有第一个线程启动的时候，开销与创建进程相当，但是后续线程就省事了。同一个进程里面的多个线程之间是共用了进程的同一份资源，比如内存（线程1 new的对象在线程234中都可以直接使用）和文件描述符表（线程1打开的文件在线程234中都可以直接使用）。

进程是操作系统进行资源分配的基本单位，而操作系统是以线程为单位进行调度的。

关于进程的调度，是每个进程里面只有一个线程这样的情况，如果每个进程里面有多个线程了，每个线程是独立在CPU上调度的。其中一个线程也是通过一个PCB来描述的，一个进程里面可能是对应一个PCB，也可能是对应多个PCB。PCB的状态、上下文、优先级和记账信息都是每个线程有自己的，各自记录各自的。但是同一个进程里面的PCB之间的pid是一样的，内存指针和文件描述符表也是一样的（在Linux中不区分TCP和PCB，都用一个表示）。

关于多线程问题，当线程足够多，而系统资源有限的情况下，可能会引发线程安全问题；还有就是其中一个线程出现异常，那么很可能把整个进程都带走，其他线程也就跟着凉凉了（我们看到谷歌浏览器就是每个页面都是做的一个进程，所以谷歌浏览器占用的系统资源挺多的）。

在Java中进行多线程编程，要依赖于操作系统提供的API。关于Java能够跨平台，其实是靠无数个不同版本的JVM支持的，比如windows系统实现了一个windows版本的JVM，Linux系统实现了一个Linux版本的JVM，Mac系统实现了Mac版本的JVM，这些不同的JVM内部封装了不同系统的API。

 Java操作多线程，依赖最核心的类Thread。

关于t1.start;是线程中的特殊方法，启动一个线程。Start的工作就是创建一个新的线程，新的线程负责执行run()方法。Start就是调用了操作系统的API，通过操作系统的内核创建新线程的PCB，并且把要执行的指令交给到这个PCB，当PCB被调度到CPU上执行的时候，也就执行到了线程run方法中的代码了。

关于操作系统调度线程，是“抢占式执行”，具体哪一个线程先上哪一个线程后上是不确定的，取决于操作系统调度器具体的实现策略。

关于start和run的区别？

Start是真正在系统上创建一个线程，线程是一个独立的执行流。而run只是描述了线程要干的活是啥。如果直接在main方法中调用run，那么此时是没有创建新的线程的，全是main所在线程一个人干活。

我们可以使用JDK自带的工具jconsole来查看当前java进程中的所有线程。

 

 

Java中创建线程的五种写法

1.继承Thread，重写run

 

package threadtest;
class MyThread1 extends Thread{
    @Override
    public void run() {
        while (true) {
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new MyThread1();
        t1.start();//注意：这里start并没有调用run方法，而是创建了一个新的线程，由新的线程来执行run方法。
        while (true) {
            System.out.println("hello main方法");
            Thread.sleep(1000);
        }
    }
}

 2.实现Runnable接口

 

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

    @Override
    public void run() {
        System.out.println("hello thread");
    }
}
public class ThreadDemo3 {
    public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        Thread t1 = new Thread(runnable);
        t1.start();
    }
}

 这样的写法可以解耦合，目的就是让线程和线程需要干的活分开。

3.使用匿名内部类，继承Thread

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

 new Thread(){}创建了一个Thread子类，子类没有名字所以叫做匿名，创建了子类的实例，并且让t引用指向该实例。

4.使用匿名内部类，实现Runable

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello runnable");
            }
        });
        t.start();
    }
}

 这个写法与第二个本质是相同的，只不过是把实现Runnable任务了交给匿名内部类。此处是创建了一个类，实现了Runnable，同时创建了类的实例，并且传给了Thread的构造方法。

5.使用Lambda表达式

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

 把任务用Lambda来描述，直接把Lambda传给Thread方法。