线程的基础

@@@wang

于 2024-04-14 18:11:32 发布

阅读量997

点赞数 25

文章标签： java

本文链接：https://blog.csdn.net/2201_76027754/article/details/137745732

版权

本文探讨了进程和线程在并发编程中的角色，比较了它们的优缺点，重点讲解了Java中的Thread类和Runnable接口，以及线程的创建、等待、状态和安全问题，强调了多线程调度的随机性和同步机制的重要性。

摘要由CSDN通过智能技术生成

前言：

我们再看线程之前肯定已经学了一个东西叫做进程，进程同线程一样都可以在系统cpu上去调度执行，那为啥有了进程，我们还要学习线程呢？？这是因为计算机是实行并发编程的，每次进程在去系统api上调度执行的时候，系统都会重新为其分配系统资源，这也有了一个概念：进程是资源分配的基本单位，这样如果实行多进程编程的时候，系统创建/调度/销毁进程的效率就会变成很慢，这也是它重量级进程名字的来源！！所以这才有了线程！！

1.进程的缺点和线程的优点（相比较于进程）

进程的缺点主要是体现在多进程编程的时候，现有如下一个例子：

有一个工厂只有一条生产线，现在它的产品买的火爆，需要扩大生产，这时候该怎么做呢？？

法一：在找一块地，然后再在原来基础开辟一条生产线 ==> 多进程

法二：再在原来的工厂增加一条生产线 ==> 多线程

相比较于法一，法二的方式，更加符合实际生存需求，法一所消耗的人力，物力，和空间都是原来的一赔，而法二只需要物力（再增加一条生产线）。法二体现的思想就是多线程的思想。

所以进程相较与线程更“笨重”，也就为重量级线程，而线程为轻量级进程！！

2.线程（轻量级进程，Thread）

（1）线程的特点：

a.每个线程都可以独立地去CPU上调度执行。

b.线程是不能独立存在的，它是依附于进程的，进程包含线程（可以有一个线程，也可以有多个线程）。

c.同一个进程中的不同线程共用同一份内存空间和文件资源（硬盘资源）（不同线程在同一个进程中创建是会直接复用之前系统分配给进程的资源（内存 + 硬盘），于是创建的效率更高）

d.线程是调度执行的基本单位，是轻量级进程。

3.进程与线程的区别：

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

b.包含关系：进程包含线程，一个进程里面可以有一个线程，也可以有多个

c.进程与进程之前是相互独立的，因为每个进程在创建的时候都会向系统申请资源（内存+硬盘），这个过程效率是低下的！！

d.同一个进程的不同线程之前的关系是相互影响，因为它们共用同一份内存空间和文件标识符，每次创建一个线程时都不用向系统申请资源，会复原之前分配给进程的资源，这个过程效率是高效的！！

4.Thread类（线程）

Thread类是java标准内置库中的类，在java.lang（String也在这个包中）这个包中，该包是不需要导入的！！

（1）创建一个线程（创建一个Thread类）

a.继承Thread类：

Thread t2 = new MyThread(); java里面推荐向上转型的写法

class MyThread extends Thread {
    @Override
    public void run() {
        while(true) {
            System.out.println("我的线程启动");
            //在Thread类的源代码中查看sleep方法
            //是一个静态方法且调用可能会抛出异常，所以必须要显示处理
            try {
                Thread.sleep(1000); //表示休眠1000ms（1s）
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

b.实现Runnable接口

Runnable接口中有run方法所以必须要重写！！使用Runnable接口的写法与直接继承Thread之间的区别是：前者能够解耦合（进程与任务之间无太大的关系，任务由谁来执行，并无指定的进程，应尽量使用）。Runnable表示的是一个可以执行的任务，这个任务交给进程还是其他实体执行，Runnable本身并不关心，当一个任务必须交给某个进程执行的时候，此时就表示进程与任务具有一定的耦合关系。

Runnable r = new MyRunnable();

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我的任务！！");
    }
    
}

c.使用匿名内部类创建线程：

//普通的匿名内部类创建方法
Thread t1 = new Thread() {
    @Override
    public void run() {
        System.out.println("线程t1启动");
    } 
};

//带Runnable的匿名内部类创建方法        
Thread t2 = new Thread(new Runnable() {
            
    @Override
    public void run() {
        System.out.println("t2");
    }
});

d.使用lambda表达式（最常用）

本质上是一个匿名函数（用一次就完了），主要用来实现回调函数的效果，且使用lambda表达式不需要重写run方法（因为其本身就是run方法，是线程的入口）

Thread t = new Thread( () -> {

...........

});

（2）Thread的构造方法：

a.Thread（）：无参构造

b.Thread（Runnable target）：使用Runnable构造

c.Thread（String name）：创建线程，并取名

d.Thread（Runnable target， String name）

Thread t3 = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("t3线程");
    }
}, "新线程");

（3）Thread类的一些属性：

a.ID ==> getId() :线程的身份标识（不是系统api提供的id也不是PCB的id）

b.名称 ==> getName()

c.状态 ==> getState()

d.优先级 ==> getPriority() :优先级高理论上会更容易被调用，这个过程在是“微观的”，我们人是觉不出来的，我们只会感觉是同时进行的，但在计算机上优先级高的先被调用

e.是否为后台线程 ==> isDamon() :后台线程对于整个线程的结束是没有影响的，但是前台线程是有影响的！！默认下一个线程是前台线程。可以通过setDamon(boolean b)的方式来设置当前线程是否为什么线程！！

f.是否存活 ==> isAlive() ：线程在未启动前是false，启动了之后就是true，当整个线程已经执行完毕，但Thread对象还在此时就是false！！

g.是否被中断 ==> isInterrupted()：通过Thread.currentThread().isInterrupted()来判断当前线程四否被中断（Thread类中有一个标志位，其可以用来判定线程是否结束。可以通过interrupted方法来中断当前的线程，将其标志位设置为true），其中Thread.currentThread()获取到当前线程的实例（谁调用currentThread方法就获取到谁的一个线程实例）。

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

    Thread t4  = new Thread(() -> {
        while(!Thread.currentThread().isInterrupted()) {
            System.out.println("线程开始工作");
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e) {
                //1.假装没看见，继续循环
                //e.printStackTrace();
                //2.加一个break跳出循环
                //e.printStackTrace();
                //break;
                //3.其他操作
                //e.printStackTrace();
                //其他操作
                //break;
                   
            }
        }
    });
    t4.start();
    Thread.sleep(2000);
    System.out.println("让线程终止");
    t4.interrupt();
}

上述代码的运行结果为：

正常来说sleep会休眠时间到才能被唤醒，此处给的interrupted方法可以让sleep内部触发一个异常，从而提前被唤醒。当interrupted唤醒线程之后，此时sleep方法抛出异常，同时会自动清除刚才的标志位（最初为false，然后当调用interrupted方法后标志位会被设置为true，然后接下来true会被清除，标志位重新被设置为false，所以如果在抛出异常后不在捕获中进行处理的话就会一直循环）。所以当线程接受到“要中断”这样的信号的时候，能够自由决定，接下来怎么处理让我们有更多操作的可能（捕获里进行操作） ==> 前提是通过“异常”的方式唤醒。