多线程的实现和成员方法

举报
2的n次方 发表于 2024/10/24 13:01:26 2024/10/24
【摘要】 1. 多线程的概念线程：线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程的实际运作单位下面这些每一个能够运行的软件就是一个进程进程在系统中是通过PCB这样的结构体来描述，通过链表的形式来组织的，线程也同样是通过PCB来描述的，一个进程就是一组PCB，也就是一个进程包含了多个线程，每一个线程都可以独立的到CPU上执行对于一个可执行程序，运行时操作系统就会创建进程，给这个程序...

1. 多线程的概念

线程：线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程的实际运作单位

下面这些每一个能够运行的软件就是一个进程


进程在系统中是通过PCB这样的结构体来描述，通过链表的形式来组织的，线程也同样是通过PCB来描述的，一个进程就是一组PCB，也就是一个进程包含了多个线程，每一个线程都可以独立的到CPU上执行

对于一个可执行程序，运行时操作系统就会创建进程，给这个程序分配各种系统资源（CPU，内存，硬盘，网络带宽...），同时也会在这个进程中创建多个线程，这些线程再到CPU上调度执行，同一个进程中的这些线程，是共用一份系统资源的

线程相比于进程更加轻量，省去了创建线程资源分配的过程和销毁线程释放资源的过程

并发：在同一时刻，有多个指令在单个CPU上交替执行

并行：在同一时刻，有多个指令在多个CPU上同时执行

也就是，有多个核心，每个核心都可以执行一个线程，这些核心之间的执行过程是同时执行的，也就是并行，此外，一个核心也可以按照“分时复用”，来切换多个线程，虽然说多个线程是一个接一个执行的，由于调度速度足够快，就好像同时进行一样，这也叫做并发

进程和线程的概念和区别：

  1. 进程包括线程，一个进程里面可以有单个或多个线程，但不能没有
  2. 进程是系统资源分配的最小单位，线程是系统调度执行的最小单位
  3. 同一个进程里的线程之间共用一份系统资源
  4. 线程是当下实现并发编程的主流方式，通过多线程，就可以充分利用好多核CPU，但是线程也不是越多越好，线程数目达到一定程度，把多个核心充分利用之后，此时再增加线程，就无法提升效率了，还可能影响效率（线程调度也是有开销的）
  5. 多个线程之间可能会相互影响，如果出现线程安全问题，一个线程抛出异常，也可能会把其他线程一起带走
  6. 多个进程之间一般不会相互影响，一个进程崩溃了，不会影响到其他进程（进程的隔离性）

2. 多线程的实现方式

2.1. 继承Thread类的方式进行实现

实现方式：

1. 定义一个类，继承Thread

2. 重写run方法

3. 创建子类对象，并启动线程


public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "hello");
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        //设置线程对象名称
        t1.setName("线程一：");
        t2.setName("线程二：");
        //开启线程
        t1.start();
        t2.start();
    }
}

在开启线程之后，会交替执行线程一和线程二

在上面的方法中，run方法没有手动的进行调用，最终也执行了，像这样的没有手动调用，最终这个方法被系统，库或者框架进行调用了，这种方法就称为“回调函数”

当调用start()方法时，会启动一个新的线程来执行run()方法中的代码。如果不调用start()方法，仅仅创建了线程对象，并不会创建新的线程执行任务。


​

也可以通过内部类的方式实现：

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Hello");
            }
        };
        thread.start();
        System.out.println("main");
    }
}

使用匿名内部类的形式，一般就是一次性的类，比较方便，内聚性也比较好

2.2. 实现Runnable接口的方式进行实现

实现方式：

  1. 自定义一个类，实现Runnable接口
  2. 重写里面的Run方法
  3. 创建自定义类的对象
  4. 创建一个Thread类的对象，并开启线程
public class MyRun implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i < 10;i++){
            //获取当前线程对象
            Thread t = Thread.currentThread();
            System.out.println(t.getName() + "hello");
        }
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
        //创建MyRun对象，表示多线程要执行的任务
        MyRun myRun = new MyRun();
        //创建线程的对象
        Thread t1 = new Thread(myRun);
        Thread t2 = new Thread(myRun);
        //给线程设置名字
        t1.setName("线程一：");
        t2.setName("线程二：");
        //开启线程
        t1.start();
        t2.start();
    }
}

开启线程之后也是交替执行线程一和线程二


​

还可以通过匿名内部类的方式来实现：

public class ThreadDemo2 {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            int n = 10;
            @Override
            public void run() {
                while (n-- != 0) {
                    System.out.println("hello");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread.start();
        while (true) {
            System.out.println("main");
            Thread.sleep(1000);
        }
    }
}

既然可以使用内部类的形式了，那么也可以用lambda表达式来进行简化：

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

2.3. 利用Callable接口和Future接口方式实现

实现方式：

1. 创建一个类MyCallable实现Callable接口

2. 重写call方法（返回值代表多线程运行的结果）

3. 创建MyCallable对象（表示多线程要执行的任务）

4. 创建FutureTask对象（作用管理多线程运行的结果）

5. 创建Thread类的对象并启动（表示线程）

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}
public class ThreadDemo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建MyCallable对象（表示多线程要执行的任务）
        MyCallable myCallable = new MyCallable();
        //创建FutureTask对象（作用管理多线程运行的结果）
        FutureTask<Integer> ft = new FutureTask<>(myCallable);
        //创建Thread类的对象并启动（表示线程）
        Thread t1 = new Thread(ft);
        t1.start();
        Integer res = ft.get();
        System.out.println(res);
    }
}

2.4. 三种实现方式对比

优点

缺点

继承Thread类

编程简单，可以直接使用Thread中的方法

可拓展性差，不能再继承其他类

实现Runnable接口

拓展性强，实现该接口同时还可以继承其他类

编程相对复杂，不能直接使用Thread中的方法

实现Callable接口

3. 常见的成员方法


​

3.1. getName()和setName()

对于setName()来说，如果没有给线程设置名称，也是有默认的名字的，格式：Thread - X(x序号从0开始)


​

根据Thread类的空参构造可以看出，在创建对象时的默认名称格式

那怎么在自定义类中创建对象时就传入对象名称进行构造呢？

在多线程第一种实现方式中，自定义的类继承了Thread类，但是构造方法并没有继承，所以还需要在自定义类中手动的去实现构造方法


​

3.2. currentThread()和sleep()

currentThread可以获取当前线程的对象

当JVM虚拟机启动之后，会自动开启多条线程，其中一条线程就叫做main线程，作用就是调用main方法，并执行里面的代码


​

sleep()是让线程休眠指定的时间，单位是毫秒，哪条线程执行到这个方法，那么哪条线程就会休眠，时间到了之后会继续执行下面的操作

这里的异常可以直接抛出


再来看MyThread类，这里的异常处理不能使用Throw抛出了，因为父类Thread没有抛出，这里只能使用try-catch处理异常


​

3.3. getPriority()和setPriority()

3.3.1. CUP的调度方式

CUP的调度方式是有两种的：分为抢占性调度和非抢占性调度

抢占式调度是一种允许高优先级线程中断低优先级线程的执行，从而立即获得CPU资源的调度方式。在这种模式下，操作系统会定期检查线程的优先级，并根据需要切换线程的执行， 对线程的访问是随机的

非抢占式调度是一种允许线程独占CPU直到其主动放弃或执行完毕的调度方式。在这种模式下，线程的执行时间由线程本身控制，调度器不会中断正在执行的线程，轮流执行线程

3.3.2. 优先级

来看Thread类中优先级的设置，最小为1，最大为10，默认是5，优先级越高抢占到CUP的概率越高，只是说概率高，并不是优先级高的就肯定比优先级低的要先抢占到CUP


​

public class ThreadTest2 {
    public static void main(String[] args) {
        //创建线程要执行参数的对象
        MyRunable myRunable = new MyRunable();
        //创建线程对象
        Thread thread1 = new Thread(myRunable,"线程一");
        Thread thread2 = new Thread(myRunable,"线程二");

        //获取线程优先级
        System.out.println(thread1.getPriority());
        thread2.setPriority(10);
        System.out.println(thread2.getPriority());

        System.out.println(Thread.currentThread().getPriority());
    }
}

3.4. setDaemon()

设置为守护（后台）线程也类似于备胎线程，当前台线程执行完毕之后，守护线程会陆续结束（并不是立即结束）


​

public class ThreadTest3 {
    public static void main(String[] args) {
        MyThread1 thread1 = new MyThread1();
        MyThread2 thread2 = new MyThread2();
        thread1.setName("女神");
        thread2.setName("备胎");
        //把第二个线程设置为守护线程
        thread2.setDaemon(true);
        thread1.start();
        thread2.start();
    }
}

应用场景：例如在聊天软件中，当打开聊天窗口之后，开启聊天窗口的线程和发送文件的线程，这时就可以把发送文件设置为守护线程，当聊天窗口关闭之后，守护线程也就没有存在的必要了

3.5. isAlive()

代码中，创建的new Thread 对象，生命周期和内核中实际的线程是不一样的，可能就会出现这种情况：Thread对象仍然存在，但是内核中的线程不存在了的情况（但不会出现相反的情况），原因就是调用start()之前，还没有创建线程，或者是run执行完了，内核的线程就没有了，但是Thread对象还存在

isAive()是判断线程是否存活的，返回一个boolean值

public class ThreadDemo3 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 3; i++) {
                System.out.println("thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        System.out.println(thread.isAlive());
        thread.start();
        System.out.println(thread.isAlive());
        Thread.sleep(2000);
        System.out.println(thread.isAlive());
    }
}


​

由于线程之前调度顺序是不确定的，休眠结束后谁先执行不一定（也并不是都是一半的概率，这种概率会随着系统的不同和代码运行环境的不同，都可能存在差异）

​

【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
任务调度 多线程
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入