【多线程初阶】认识线程

目录

1.认识线程

1.1线程的引入

1.2进程与线程的区别（面试题）

2.Thread类及其常见方法

2.1构造线程的常见方法

2.2线程的常见属性

2.3启动一个线程-start() 

2.4中断一个线程

2.5等待一个线程-join()

2.6休眠当前线程-sleep()

3.线程的状态

---

1.认识线程

1.1线程的引入

在认识线程之前要先了解一下进程。引入多个进程是在多核CPU时代实现并发编程的刚需，然而创建，销毁，调度一个进程消耗时间比较多，效率不高。进程是资源分配的基本单位，消耗在申请资源上的时间较多，于是分配内存操作便成了一个大工程。

为了解决以上问题，就引入了线程（Thread），线程也叫做”轻量级进程“。它不能独立存在而要依附于进程。所以创建线程的时候，不需要再重新申请资源了，直接复用之前已经分配给进程的资源，创建效率就更高了。

举例：

阿红家的工厂想扩大生产规模，多增加一条生产线。现在两个方案，请你思考哪一个方案更节约成本呢？

显然，方案二更节约成本并提高了效率。方案一就是多进程的方式，方案二就是多线程的方式。

1.2进程与线程的区别（面试题）

1.进程包含线程，一个进程里至少有一个线程。

2.同一个进程里的线程之间共享一份资源（内存+硬盘），节省了申请资源的开销。

3.进程与进程之间具有独立性，一个进程的好坏不影响别的进程。同一个进程内的线程之间可能相互影响。

4.进程是资源分配的基本单位，线程是调度执行的基本单位。

2.Thread类及其常见方法

2.1构造线程的常见方法

*继承Thread类并实现run方法

步骤：1.继承Thread创建一个线程类->2.创建MyThread的实例->3.调用start（）方法启动线程

class MyThread extends Thread {
    @Override
     public void run() {
        System.out.println("hello, thread！");
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
  
        MyThread01 t = new MyThread01();
        t.start();
    }
}

*实现Runnable接口，并实现run方法

步骤：1.实现Runnable接口->2.创建Thread类实例，将Runnable对象作为目标参数->3.调用start（）方法启动线程

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

public class ThreadDemo{
    public static void main(String[] args) {
        // 实例化Runnable对象
        MyRunnable01 runnable = new MyRunnable();
        Thread t = new Thread(runnable);
        t.start();
    }
}

使用Runnable接口的好处？

1.解耦：通过实现Runnable接口，并在run方法中实现具体的任务，将线程与任务分离，可以在需要执行该任务的地方创建一个线程，并将任务传入线程中执行。

2.提高代码复用性：实现Runnable接口可以让多个线程共享同一个任务对象，减少重复代码的编写，同时方便统一修改。

*继承 Thread, 重写 run, 使用匿名内部类

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

*实现 Runnable, 重写 run, 使用匿名内部类

public class ThreadDemo {
        public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());                
            }
        });
        
        t.start();
    }
}

*使用 lambda 表达式

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

2.2线程的常见属性

属性	获取方法	解释
ID	getID()	ID是线程的唯一标识
名称	getName()	各种调试工具用得到
状态	getState()	表示线程当前所处的情况
优先级	getPriority()	优先级高的更容易被调度到
是否后台线程	isDaemon()	后台线程不会影响进程结束，而前线程会影响进程结束。
是否存活	isAlive()	看run方法是否运行结束
是否被中断	isInterrupted()	让run方法尽快执行结束

2.3启动一个线程-start() 

(面试题：start和run的区别)

前面知道了重写run方法是为了创建一个线程对象，但线程对象创建出来并不意味着线程开始运行，run方法只是描述出了线程要执行的内容。而调用start()方法才是线程真正去独立执行了。本质上的差别就是有没有在系统内部创建新的线程。

2.4中断一个线程

线程中断是指一个线程发送中断请求给另一个正在执行的线程，让该线程停止执行当前任务。但不立即中止线程执行，而是设置了一个中断标志，当线程在阻塞状态时检查这个标志，并根据需要中止执行。

Thread收到中断信号的方式有两种：

1.当线程在阻塞状态时，以InterruptedException异常的形式通知，清除中断标志。

2.内部的一个中断标志被设置，可以通过：

Thread.interrupted()判断当前中断标志被设置，清除中断标志

Thread.currentThread().isInterrupted()判断指定线程的中断标志被设置，不清除中断标志。

public class demo {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            //Thread类内部有一个现成的标志位，可以同来判断当前循环是否要结束
            while (!Thread.currentThread().isInterrupted()){
                System.out.println("线程工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //1.假装没收到，继续正常执行循环
                    e.printStackTrace();
                    //2.加上一个break,表示线程立即结束
                    //break
                    //3.做一些收尾工作再结束
                    break;
                }
            }
        });
        t.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("让线程t终止");
        t.interrupt();//把上述Thread对象内部的标志位设为true了
    }
}

2.5等待一个线程-join()

使用Thread类中的join()方法明确等待线程结束，当有新线程加入时，主线程会进入等待状态，一直到新线程执行结束为止。

public class demo20 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                System.out.println("t线程工作中！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        /*让主线程等待t线程执行结束
        一旦调用join，主线程就会触发阻塞，此时t线程就可以趁机完成后面的工作
        一直阻塞到t执行完毕，join才会解除阻塞，主线程才能继续执行*/
        System.out.println("join等待开始");
        t.join();
        System.out.println("join等待结束");
    }
}

2.6休眠当前线程-sleep()

sleep()方法可以让线程进入休眠状态，不会占用CPU资源，也不会释放锁。过了规定时间 后继续执行代码。

sleep()和wait()方法的异同：

1.相同点：都可以使线程暂停执行

2.不同点：

sleep()方法是Thread类的静态方法，而wait()方法是Object类的实例方法

sleep()可以在任何地方使用，wait()通常搭配synchronized使用

sleep()不会释放锁，而wait()会释放对象的锁

sleep()用于控制线程执行的时间间隔，wait()通常用于线程间的通信和同步操作

3.线程的状态

线程的状态是一个枚举类型Thread.State

NEW （新建）: 对象创建好了，但是还没有调用start()方法开始行动。

RUNNABLE （运行）: 分为正在工作的和即将开始工作的，准备CPU的调度。

BLOCKED（阻塞） : 由于锁竞争导致的阻塞。

WAITING （等待）: 由于wait这种不固定时间的方式产生的阻塞，处于这个状态的线程会释放持有的锁。

TIMED_WAITING（计时等待）:由于sleep这种固定时间的方式产生的阻塞，超出等待时间会自动唤醒。

TERMINATED（终止）:对象还在，内核中的线程没了，无法再次启动。

实际中线程状态可能会相互转换，线程的状态转换由Java虚拟机和操作系统共同管理。