当前位置：首页 > article >正文

多线程（一）：线程的基本特点线程安全问题ThreadRunnable

article 2024/11/20 17:22:32

1、线程的引入

2、什么是线程

3、线程的基本特点

4、线程安全问题

5、创建线程

5.1 继承Thread类，重写run

5.1.1 创建Thread类对象

5.1.2 重写run方法

5.1.3 start方法创建线程

5.1.4 抢占式执行

5.2 实现Runnable，重写run【解耦合】★★★

6、知识拓展

6.1 拓展一：名词解释——api

6.2 拓展二：异常处理方式

6.3 拓展三：名词解释——客户端&服务器

6.4 拓展四：高内聚，低耦合

6.4.1 耦合

6.4.2 内聚

1、线程的引入

大家都知道，当代CPU为多任务处理器，具备多个核心，而为了充分发挥CPU多核心的性能，避免出现“一核有难，多核围观”的情况，“并发编程”就成为刚需。

而通过多进程的方式，可以实现“并发编程”的效果。

虽然说多进程的方式可以实现“并发编程”，但是要知道，进程整体是一个比较“重量级”的概念，如果频繁的创建与销毁，开销是很大的。

尤其是对于服务器来说，一个服务器会为多个客户端提供服务，服务的客户多了，进程的创建与销毁操作自然也会增多。

举个例子：此时，我们打开了百度的网页，但是，这时全国甚至全球会有大量的用户与我们进行相同的操作，会有大量用户对服务器发送大量的请求，大量的进行创建与销毁操作，如果采用多进程方式的话，开销是很大的。

为了解决上述问题，引入一个轻量级的概念——线程（thread）。

2、什么是线程

线程（thread）又称为轻量级进程。

也就是说，线程是一个轻量级的东西，它的创建与销毁的开销要比进程小得多。

因此，可以通过多线程的方式，来实现“并发编程”。

3、线程的基本特点

上篇博客说到，一个进程，相当于一个要执行的任务。

而，一个线程，也相当于一个要执行的任务。

线程与进程的区别如下：

进程包含线程：每个进程中，都会有一个或者多个线程。且至少有一个线程，这个线程在进程创建时随进程一起创建，称为主线程。
进程是操作系统资源分配的基本单位，每个进程都会分配一定的CPU资源、内存资源、硬盘(文件描述符表)资源、网络带宽资源.....。也就是说，在进程创建时，需要申请资源；在进程销毁时，需要释放资源。（会增大系统开销）
而对于线程来说，在进程内部管辖的多个线程之间，会共享进程分配到的资源。对于线程，只是在第一个线程创建时(随进程创建时创建的主线程)需要申请资源，后续再创建的线程，不需要进行资源申请操作。且只有所有的线程都销毁(进程销毁)时，才会释放资源，运行过程中销毁某个进程，也不会释放资源。（系统开销低）
进程和进程间，每个进程分配到的资源都是各自独立的，彼此之间互不干扰，具有稳定性。
进程内部的线程间，会出现相互影响的情况，具有“线程安全问题”。
上文所讲的“进程调度”，准确的来说，其实是“线程调度”(当一个进程中只有一个线程时，可以称为“进程调度”)。也就是说，线程是CPU上调度执行的基本单位。如果一个进程中有多个线程，那么这些线程是各自去CPU上调度执行的（可能多个线程由1个核心执行(并发)，也可能多个线程由多个核心同时执行(并行)，也可能在不同的CPU上来回切换），具体线程是怎么调度执行的，由操作系统内部“调度器”自行完成，程序猿感知不到也干预不了。
每个线程，都会有属于自己单独的调度相关的信息：线程状态、线程上下文、线程优先级、线程记账信息。（也就是说，如果一个进程中有10个线程，就会有10份这样的信息）。但是，一个进程中的线程，共用一个文件描述符表和内存指针。

4、线程安全问题

对于线程安全问题，先举个例子：

一个房间的桌子上放着100只烧鸡，把小明同学叫来，让他把这100只烧鸡全部吃完(小明相当于一个线程)，但是一个人吃100只鸡，显然效率很低。于是，再把小刚同学叫来(再创建一个线程)，让小刚和小明共同把这100只鸡吃完。此时，两个人吃100只鸡，显然比一个人吃100只鸡的效率要高的多。如果再叫来两三个其他同学，这时的效率就会更高。但是如果一直再叫来其他同学，比如叫到了50名同学，50名同学共同吃这100只鸡，其中两人都想吃同一只鸡，这两人间就会发生冲突(即线程安全问题)，甚至冲突过大会把桌子掀翻，这时所有的人都吃不了鸡了(直接带走进程，所有线程无法继续工作)。

综上，总结如下：

虽然多线程的方式能够提高工作效率，但是也并非“线性增长”，当一个进程中的线程过多时，线程与线程间就会出现互相影响的情况，会拖慢效率，甚至会抛出异常使整个进程终止(如果及时捕捉到异常，也是不会终止的)。
线程数目如果太多，线程的调度开销也会非常明显，会因为调度开销拖慢程序性能。

5、创建线程

线程，是操作系统提供的概念，同时操作系统也提供了一些线程相关的api供程序员使用。

操作系统提供的原生api是C语言写的，并且不同操作系统所提供的线程api是不同的，是不是我们Java程序猿就得去学习C语言呢？

并不是的，Java对操作系统提供的线程api统一进行了封装，在标准库中提供了Thread类，我们可以通过Thread类来创建和使用多线程。

而创建线程的方式有两种：

继承Thread，重写run
实现Runnable，重写run

5.1 继承Thread类，重写run

5.1.1 创建Thread类对象

Thread类被封装在了java.lang包中，java.lang是Java的核心包，包含了String、Math、System、Thread、Runnable等等，这个包中的类被自动导入到每个Java程序中，无需显式导入。所以当我们使用Thread类时，不会自动显示导入包。

5.1.2 重写run方法

作为程序员，我们需要创建一个类继承于Thread并且重写其中的run方法，在run这个方法中，我们可以根据自己的思维将这个线程要做的任务写在这个run方法中。

这个run方法，就相当于线程的入口。

为后续观察多线程的状态，这里使用死循环的方式打印“hello thread”，再使用Thread中静态的sleep方法休眠1秒(防止CPU红温)。

使用sleep方法会抛出受查异常，解决方法有两个：

throws：进行异常声明
try-catch：进行异常捕获

但是由于run为重写方法，不能使用throws在函数头声明，只能使用try-catch捕获。

5.1.3 start方法创建线程

start方法的作用是真正创建一个新的进程，相当于多了一个执行流，多了一个干活的人，让代码能够“一心两用”，同时做两件事。

在main方法(主线程)中使用Thread对象调用start方法创建线程，并且在main方法中循环打印“hello main”，观察多线程现象。

注意，start的作用才是创建线程，run方法只是线程的入口，不是创建线程。

如果按照我们之前学习的程序运行逻辑，程序遇到死循环就会一直停留在那里(单线程模式)，但是我们现在创建了多个线程，会发生什么样的情况呢？

多线程运行：

运行后，“hello main”和“hello thread”无规律交替打印，这就是多线程。

class MyThread extends Thread{
    @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 {
        Thread thread = new MyThread();
        //start -> 真正的创建线程
        thread.start();
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

5.1.4 抢占式执行

观察到，“hello main”和“hello thread”的打印是随机的，也就是，这两个线程的调度是随机的，谁先执行，谁后执行，都是无法预测的，我们称这种情况为“抢占式执行”，通俗来说，就是谁先抢到谁就先执行。

我们唯一能做的就是给线程设置优先级，但是对于操作系统来说，也只是仅供参考，不会一定的按照优先级的顺序来调度执行。

5.2 实现Runnable，重写run【解耦合】★★★

我们可以把要重写的run方法抽象出来，使用自定义类实现Runnable接口，在类中重写run方法(即要完成的任务)，将要完成的任务和线程分离开来，实现与线程Thread的解耦合。

就是仅仅把runnable当做一个任务，单纯的把任务抽象到runnable接口的run方法中，最后线程还是要靠Thread来创建。

这样解耦合的有以下优点：

将所要完成的任务和线程分类开来，而不是把任务直接写到线程当中
以后可以通过其他方式执行该任务(不一定是在线程中)，使线程是线程，任务是任务。
方便以后修改任务时不会影响到线程，方便代码的维护(容易改，不会一改一大片)

class MyRunnable implements Runnable {

    @Override
    public void run() {//run --> 相当于线程的入口
        while (true) {
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) throws InterruptedException {
        //任务
        Runnable runnable = new MyRunnable();
        //线程
        Thread thread = new Thread(runnable);
        //start --> 真正的创建线程
        thread.start();
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

6、知识拓展

6.1 拓展一：名词解释——api

上文很多地方都提到了api，但是大家都知道啥是api嘛？

api（application programming interface），应用程序编程接口。

通俗来说，api就是别人写的一些函数/类，你直接拿过来就能用。

api是一个广义的概念，操作系统会提供api、标准库会提供api、第三方库会提供api、其他各种开源项目会提供api、甚至工作中项目组给你的代码中也会提供api。

api也可以理解为，别人给你提供的库/程序，你都能用来干啥。

举个例子：对于同班同学，你可以给他在微信上发消息、可以问他题、可以和他聊天、....，这是你同学向你提供的api；你谈了个对象，你可以和你的对象亲亲抱抱举高高....，这是你对象向你提供的api。

而基于api，你可以用来编程（api的目的就是用于编程）。

比如接上例，基于你同学或者对象向你提供的api，你可以做出规划(编程)：周末约同学打球；周末约对象看电影......

而对于Java程序猿的我们，我们可以使用标准库向我们提供的api去编程，比如ArrayList、StringBuffer、.......

在计算机界，Demo/Sample/quick start 的意思是示例、演示的意思，告诉我们如何使用。

而test是更为详细的测试过程。

6.2 拓展二：异常处理方式

在上文中，我们提到对于受查异常有两种处理方式：

throws
try-catch

当我们使用IDEA进行自动的异常处理时，它是这样处理的：

它在catch中又重新拋了一个新的异常，只不过拋了个非受查的异常，所以没有再编译报错了，这种方法仅仅是满足了语法的要求，但是对于异常来说，就相当于没处理异常。在实际开发中，我们并不会这么干~

在实际工作中，通常会这样处理异常：

记录异常信息作为日志，后续根据日志调查问题。——使程序仍然正常执行，不会因为这个异常就终止。（不交给jvm处理）（服务器是7*24小时运行的，如果服务器因为异常导致崩溃，就无法给客户提供服务，这对于服务器来说非常关键）
进行重试。（有的异常是概率性发生的，如：网络抖动原因）
报警机制——如果是特别严重的问题，程序会立即通知程序猿处理（通过写代码来以短信、电话、微信等方式通知程序猿）。