多线程学习

车到山前必有路529

已于 2024-04-07 23:42:02 修改

阅读量1.1k

点赞数 26

文章标签：线程多线程实现并发和并行 lambda表达式线程的六种状态 java 进程和线程

于 2024-04-05 01:14:58 首次发布

本文链接：https://blog.youkuaiyun.com/qq_65568592/article/details/137227004

版权

3.2通过实现Runable接口+使用Thread类实现

3.3通过实现Callable<>接口+使用Futuretask<>类+使用Thread类实现

1.进程和线程

进程：进程是程序的一次运行，是拥有资源的基本单位。

线程：线程是处理机调度的基本单位，一个进程可以有多个线程，且至少有一个线程。

进程相当于一个公司，而线程相当于公司里面的各个部门，共同实现公司的正常运行。

补充：java默认有两条线程，一条是main线程，用于执行main方法中的代码；另一条是GC线程，用于进行垃圾回收。

1.多线程介绍

什么是多线程

有了多线程，我们就可以让程序同时做多件事情。

多线程的作用

充分利用程序运行的等待时间，让CPU在多个线程之间进行切换，从而提高程序的运行效率。

多线程的用途

只要是想让多个程序同时运行，就都会用到多线程。

以游戏为例，游戏在加载页面不仅会加载资源，还需要加载背景、检查版本等，如果没有多线程，那就需要先加载资源，然后再进行其他操作，如果需要加载大量资源，那么需要等待很长时间才会进入下一步操作。如果我们引入多线程，充分利用这些等待时间，让其他线程在加载资源的同时执行其他程序，比如检查版本加载背景，就可以缩短加载页面的时间，提高效率。

多线程其实就和小学的一种题类似，小明烧水需要2min，刷牙需要2min，使用微波炉热饭需要1min，问小明做完这些事情最少需要多长时间。如果一件一件的进行总共需要5min，就相当于是单线程，一条线程执行完一个程序后再执行另一个程序；如果小明在刷牙的同时进行烧水和热饭的操作，那总共只需要2min便会完成，这就相当于多线程，虽然也是每条线程只执行一个程序，但它们是同时进行的，充分利用了等待的时间，提高了效率。

2.并发和并行

并发

并发是指多个指令在单核CPU上交替执行。

并行

并行是指多个指令在多核CPU或多个CPU上同时执行。

3.多线程的实现方式

3.1通过继承Thread类实现

//自己的线程类，继承Thread类
public class MyThread extends Thread{

    //重写run方法
    @Override
    public void run() {
        for(int i=0;i<100;i++)
        System.out.println(getName()+"hello");
    }
}

//多线程实现
public static void main(String[] args) {
        //创建两个线程对象
        MyThread mt1=new MyThread();
        MyThread mt2=new MyThread();

        //给两个线程分别命名，用于在输出结果时区分
        mt1.setName("thread1");
        mt2.setName("thread2");

        //开启两个线程，调用start方法后会自动找到run方法并执行
        mt1.start();
        mt2.start();
    }

运行结果：

可以看到调用start开启两个线程后，线程是并发执行的，这是因为线程运行时没有加锁，没有保证原子性造成的，详细探讨可以参照另一篇博客JVM学习-JMM-优快云博客中的2.1保证原子性的部分。

那如果通过对象直接调用run方法呢？

这就是单纯的调用一个类的方法了，并没有启动两个线程，而是按照顺序先通过mt1调用run方法，再通过mt2调用run方法，运行结果就是先执行100次打印thread1hello，再执行100次打印thread2hello。所以要启动两个线程就要调用start方法。

3.2通过实现Runable接口+使用Thread类实现

//通过实现Runnable接口来写任务类
public class MyRun implements Runnable{

    //重写run方法
    @Override
    public void run() {

        //获取当前运行的线程
        Thread t = Thread.currentThread();

        for(int i=0;i<100;i++) {
            System.out.println(t.getName() + "hello");

            //或者直接链式调用
            //System.out.println(Thread.currentThread().getName() + "hello");
        }


    }
}

//实现多线程
public class Main {
    public static void main(String[] args) {

        //r相当于是要执行的任务
        Runnable r=new MyRun();
        
        //这里通过创建Thread类的对象来创建两个线程，并将任务告诉给这两个线程
        Thread t1=new Thread(r);
        Thread t2=new Thread(r);

        //给两个线程命名，用于打印时区分
        t1.setName("thread1");
        t2.setName("thread2");

        //启动两个线程
        t1.start();
        t2.start();
    }
}

由上面的代码可见，与第一种方式不同，需要先调用Thread类的静态方法currentThread来获取到当前的线程才能使用getName方法获取到线程名，这是因为getName方法是Thread类的一个方法，Runnable则是另一个接口，和Thread类无关。要注意的是获取当前线程的那一行代码不能写到run方法外面，也就是下面这种情况：

public class MyRun implements Runnable{

    Thread t = Thread.currentThread();

    @Override
    public void run() {
        Thread t = Thread.currentThread();
        for(int i=0;i<100;i++) {
            System.out.println(t.getName() + "hello");
        }
    }
}

如果获取当前进程的这行代码放到了run方法外面，则会获取到main线程。这是因为这么写就是把t作为了MyThread的一个成员变量并进行初始化，当我们在main函数中执行Runnable r=new MyThread()创建实现类对象时，就会执行MyThread类的初始化，此时正在运行的线程就是main线程，因此t就被初始化为了main线程，后面虽然启动了t1和t2两个线程，但由于没有再次获取当前线程的操作，t的值还是main线程，所以都会输出mainhello。

在上面的代码中还注意到，在main函数中我们是先实现的Runnable接口，然后是通过Thread创建的两个线程的实例，这是因为Runnable接口本身并不是用来创建线程的，而是相当于规定了一项任务，后面的new Thread(r)则是在创建线程实例的同时把这项任务赋给这个线程，告诉它要执行什么任务。

运行结果：

由于没有加锁，所以这两个线程也是并发执行的。

3.3通过实现Callable<>接口+使用Futuretask<>类+使用Thread类实现

以上两种方式都不能获取到线程运行的结果，因为无论是Thread类还是Runnable接口它们的run方法都是void的，而使用这种方式则可以获取到线程运行的结果。

//实现Callable接口，这是一个泛型接口，里面的类型就是返回值的类型
//和Runnable类似，Callable的实现类也是相当于一个任务类
public class MyCall implements Callable<String> {

    //当规定了返回值类型后再重写call方法，会自动设置重写的call方法的返回值类型
    @Override
    public String call() throws Exception {

        return "朋友们大家好，这里是MC"+Thread.currentThread().getName()+"!";
    }
}

//实现
public class Main {

    //在下面调用get时会报出异常，直接抛出即可
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        
        //实现Callable接口
        Callable<String> mc=new MyCall();

        //通过创建FutureTask<>对象来管理返回的值
        FutureTask<String> ft1=new FutureTask<>(mc);
        FutureTask<String> ft2=new FutureTask<>(mc);

        //还是用Thread来创建两个线程实例，不同的是将FutureTask<>对象赋给这两个线程实例
        Thread t1=new Thread(ft1);
        Thread t2=new Thread(ft2);

        t1.setName("子龙");
        t2.setName("曹操");

        t1.start();
        t2.start();

        //获取两个线程运行的结果并打印，因为FutureTask是管理返回值的，所以用它的实例获取
        String result1=ft1.get();
        String result2=ft2.get();
        System.out.println(result1);
        System.out.println(result2);
    }
}

运行结果：

3.4总结

实际上相对于Runnable而言，Callable不仅可以设置返回值，而且运行的效率也更高，所以Runnable一般很少用。

补充：实际上java自己并不能真正开启一个线程，因为java的代码只能运行在JVM也就是java虚拟机中，而要对线程进行调度需要操作系统来完成，所以java的start方法的底层是通过调用C++编写的本地方法来实现的，并且由此可以推断那些常用的线程调度比如sleep、wait等它们的底层都是通过调用本地方法来实现的（要注意像setName、setPriority、setDaemon等操作不属于线程调度，这属于设置线程的属性），实际上也确实如此：

3.5使用lambda表达式实现

上面三种方法是基础的实现方法，使用lambda表达式则是一种进阶的实现方式。第一种方法是继承Thread类实现，这种方式创建的对象只能是一个线程对象，执行的任务是固定的，耦合度较高；第二、三中方式使用了接口实现，创建的对象是一个任务对象，使用时将任务对象放到一个线程中运行，这两种方式使得创建的线程可以通用，能够执行各种任务，但这些任务类只能用作任务，只在一定程度上降低了耦合度；而使用lambda表达式则是进一步降低耦合度。

第二、三种方式的耦合度问题出现在所创建的类实现了一个接口，和一个接口产生了关联，所以我们干脆既不继承其他类，也不实现其他接口，所创建的类是一个独立的类，这种方式所创建的类其实就是一个普通的类，可以称其为资源类，里面只有属性和要执行的方法，在创建线程时直接将这个资源类使用lambda表达式插入即可。

lambda表达式的格式：

(参数)->{
    //要执行的方法
}

或者直接使用方法引用：

资源类对象::方法名

代码实现，以简单的售票为例：

//资源类，只有属性和方法
public class Ticket {
    //属性
    public int ticket=20;

    //方法
    public void sale(){
        while(ticket>0){
            ticket--;
            System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩"+ticket+"张票");
        }
    }
}

//实现
public class Main {
    public static void main(String[] args) {

        //创建资源类对象
        Ticket ticket=new Ticket();

        //在创建线程时使用lambda表达式
        Thread t=new Thread(()->{
            ticket.sale();
        });

        //启动线程
        t.start();
    }
}

运行结果：

使用方法引用的写法为：

//使用方法引用
Thread t=new Thread(ticket::sale);

在使用lambda表达式创建线程时可以同时设置线程名：

//在创建线程时使用lambda表达式
Thread t=new Thread(()->{
    ticket.sale();
},"线程1");

//使用方法引用
Thread t1=new Thread(ticket::sale,"线程2");

以上的售票例子中，sale方法里的循环可以放到lambda表达式中，sale方法就变成了只卖一张票：

//sale方法变为卖一张票
public void sale(){
    //卖一张票
    ticket--;
    System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩"+ticket+"张票");
}

//在创建线程时使用lambda表达式
Thread t=new Thread(()->{
    while (ticket.ticket>0) {
        ticket.sale();
        }
    },"线程1");

方法引用的方式则不行，只能将循环放到sale方法中。

4.在线程中常见的一些成员方法（导航）

详见另一篇博客多线程中常用的一些方法介绍-优快云博客。

5.线程的生命周期

一个线程的生命周期有五种状态：新建、就绪、运行、阻塞、死亡。

新建即线程实例被成功创建；就绪为线程实例执行了start方法开启线程，此时这个线程处于正在竞争CPU的状态，有执行run方法中的程序的资格，但由于还没有抢到，所以没有执行权（相当于竞选一个职位，能够竞选说明有担任这个职位的资格，但还没有竞选上说明还没有担任这个职位的权利）；运行则是线程成功抢到了CPU，正在执行run方法中的代码；阻塞则是通过调用静态方法sleep或使用其他阻塞方式让线程暂时挂起；死亡则是线程运行结束，变成了垃圾等待被回收掉。

补充：当线程在运行态时，也有可能被其他线程夺走CPU的占用权，此时一旦CPU被夺走那么该线程就会又进入就绪态，重新竞争CPU。当线程阻塞状态结束后，线程不会立刻继续执行代码，因为当该线程进入阻塞态时它所占用的CPU会被释放掉，需要重新进入就绪态竞争CPU。

但是在java中线程的状态有6种：新建状态(new)、就绪状态(runnable)、阻塞状态(blocked)、等待状态(waiting)、计时等待状态(timed_waiting)、结束状态(terminated)。

其中，生命周期中的阻塞就包括阻塞状态、等待状态和计时等待状态，当需要加锁但还没有获取到锁时处于阻塞状态，当调用wait方法时处于等待状态，当调用sleep方法时则处于计时等待状态。java中线程的状态里没有定义运行状态，只有就绪态，这是因为当线程成功抢到CPU之后线程就被交给操作系统管了，既然此时线程不归java管，那也就没有必要再定义运行状态了，下面的运行状态是为了更好理解加上的。