线程

C++的生态鼓励多进程编程，而在Java的生态中，更鼓励多线程编程

一、线程的概念

1.引入线程的目的

​ 引入多进程的目的，就是为了实现并发编程。但是进程太“重”，导致开销大、效率低。创建、销毁或者调度一个进程，消耗的时间都较多。主要消耗在申请资源上面。

​ 前文提到，进程是系统资源分配的基本单位。分配的消耗很大。

​ 例如分配内存操作：操作系统内部的数据结构，会把空闲的内存分块管理好。当我们进行申请内存时，操作系统就会从这个数据结构中，找到一块大小合适的空闲内存，返回给对应的进程。虽然数据结构会提高效率，但是由于要管理的内存很多，相比之下依然耗时。

如果进行频繁的创建和销毁进程，这时开销就不容忽视。

为了解决这个问题，就引入了线程（Thread）。

2.什么叫线程（Thread）

• 线程也叫”轻量级进程“，创建、销毁、调度线程要比进程要快。

• 线程依附于进程，不能独立存在。进程包含一个/多个线程。

• 线程是调度执行的基本单位。

一个进程可以用一个或多个PCB来表示，每个PCB对应到一个线程。

每一个线程，都有状态、优先级、上下文、记账信息等等来辅助调度。

pid、内存指针、文件描述符表是共用的。

1.线程的特点：

1.每个线程都可以独立的在CPU上进行调度。

2.同一个进程的多个线程之间，共用同一分内存空间和文件资源。

• 因此在创建线程时，不需要重新申请资源，直接复用之前分配给进程的资源。省去了资源分配的开销，提高了效率

3.当线程过多，可能对引发冲突。（两个线程同时访问一个变量：线程不安全）。当一个线程发生异常时，如果没有妥善处理，容易奔溃整个进程。

2.进程和线程的区别（面试题）：

1.进程包含线程，一个进程可以有一个线程或者多个线程。在开始时至少要有一个线程存在（主线程）——是和进程一起创建的

这个线程负责完成执行代码的操作，也可以根据需求，创建出多个线程。每个线程都可以独立执行不同的代码，从而实现并发编程的效果。

2.进程是系统资源分配的最小单位，线程是系统调度执行的最小单位。

3.进程和线程都是为了实现并发编程的需求，但是线程比进程更加高效

4.进程和进程之间不共享内存空间，同一个进程的线程之间共享同一份内存空间和文件资源，省去了申请资源的开销。

5.进程之间具有独立性，一个进程出问题，不影响其他进程，不相互干扰。用一个进程的不同线程之间，可能会相互影响

3.Java的多线程编程

线程是操作系统中的概念，操作系统提供了对应的API,来对线程进行操作。

为了跨平台，Java又对系统的API进行了封装（Thread类），通过Thread类创建Thread对象，从而操作系统内部的进程。

二、创建线程

1.继承Thread重写run

写一个类继承自Thread

Thread类是Java标准库内置的类，在java.long包的下面，不需要import

class MyThread extends Thread{
    //Java标准库内置的类，在java.long包的下面，不需要import
    @Override
    public void run() {
        //重写父类的run方法(入口方法)
        System.out.println("hello thread");
    }
}

入口方法：

每个线程都是一个独立的执行流，都可以独立执行代码。当一个线程跑起来时，从它的入口方法开始执行代码。

当运行一个Java程序时，就是跑起来了一个Java进程。这个进程里至少存在一个线程（主线程），这个主线程的入口方法就是main方法。

定义好线程后，需要对线程进行调用。

    public static void main(String[] args) {
        //在主线程中创建实例
        Thread t = new MyThread();
        //start和run都是Thread的方法
        //run 只是描述了线程的入口(线程要做什么任务)---指路的
        //start 真正调用了系统API，在系统中创建出这个线程，让这个线程再调用run
        t.start();

    }

run 只是描述了线程的入口(线程要做什么任务)

相当于一个psvm，里面是要执行的内容。

start 真正调用了系统API，在系统中创建出这个线程，让这个线程再调用run

相当于手动的绿色运行小三角，有了start才能开始创建、运行线程

class MyThread extends Thread{
    //Java标准库内置的类，在java.long包的下面，不需要import
    @Override
    public void run() {
        //重写父类的run方法(入口方法)
       while (true){
           System.out.println("hello thread");
       }
    }
}
public class CreatThread {
    public static void main(String[] args) {

        Thread t = new MyThread();
        t.start();
        while (true){
            System.out.println("hello Main");
        }
    }
}

• 此时，主线程和t线程的两个死循环在“同时执行”。日志在交替打印

​ 验证了每一个线程都是一个独立的执行流，在主线程中，遇到t线程时，兵分两路。一路去执行t进程，另一路继续执行主线程。实现了并发执行。

    public static void main(String[] args) {

        Thread t = new MyThread();
        //t.start();
        t.run();
        while (true){
            System.out.println("hello Main");
        }
    }

​ 如果把start()给成run()。将不会创建出新的线程，只有一个主线程。在主线程中执行这个对象的方法，并且死循环，不会进入到下面的循环中。

使用jconsole

使用 jconsole来观察进程中多线程的情况。

JDK中自带的工具

在JDK的目录下 ： bin/jconsole.exe

• 启动时要保证线程已经运行。

一个Java进程启动后，JVM会自动创建线程来进行一系列操作（如垃圾回收、资源统计、远程方法调用等等）

sleep

• sleep是Thread的类方法，通过类名直接调用
• 在使用sleep时，可能会抛出受查异常，必须显示处理

       while (true){
           System.out.println("hello thread");
           try {
               Thread.sleep(1000);
               //每执行一次，休眠一秒
           } catch (InterruptedException e) {
               throw new RuntimeException(e);
           }
       }

在循环体中加sleep，进行休眠。

两个线程都休眠1000毫秒，时间到了之后，谁先执行是“随机”的。操作系统对于多个线程的调度顺序是”随机“的。

概率不均等，取决于调度器的具体实现

2.实现Runnable重写run

Runnable是一个interface接口

Runnable表示的是一个“可以运行的任务”，这个任务是交给线程负责执行，还是交给其他的实体执行。Runnable本身并不关心。

class MyRunnable implements Runnable{

    @Override
    public void run() {
       while (true){
           System.out.println("hello thread");
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               throw new RuntimeException(e);
           }
       }
    }
}
public class demo1 {
    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = new MyRunnable();
        //将任务放到线程里面执行
        Thread t = new Thread(runnable);
        t.start();
        //还是通过start来创建线程
        while (true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }

使用继承Thread写法和实现Runnable接口写法的区别，主要是解耦合

创建一个线程，需要进行两个关键操作：

1.明确线程要执行的任务

任务本身不一定和线程强相关，把任务提取出来，随时对代码进行修改。 达到解耦合的效果。

2.调用系统api来创建出线程

3.使用匿名内部类创建

    public static void main(String[] args) throws InterruptedException {

        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t.start();
        while (true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t.start();
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }

    }

4.使用lambda表达式创建

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{

            while (true){
                System.out.println("hello thread!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
        while (true){
            System.out.println("hello Main");
            Thread.sleep(1000);
        }
    }

点击移步博客主页，欢迎光临~