（1）多线程之基础篇

forwardMing

已于 2023-03-28 16:10:43 修改

阅读量45

点赞数

分类专栏： # Java多线程文章标签： java jvm 开发语言

于 2023-03-27 16:22:56 首次发布

本文链接：https://blog.csdn.net/qq_43982741/article/details/129797873

版权

Java多线程专栏收录该内容

6 篇文章 0 订阅

订阅专栏

进程和线程

在Java语言里最大的特点是支持多线程的开发。

进程概念

在传统DOS系统的时代，其本身有一个特征：如果电脑上出现了病毒，那么所有的程序将无法执行，因为传统的DOS采用的单进程处理，而单进程处理的最大特点是，在同一时间点只允许一个程序执行。

后来到了windows的时代就开始了多进程的设计，在一个时间段上可以同时运行多个程序，并且这些程序将进行资源的轮流抢占，所以在同一个时间段上会有多个程序依次执行，但是在同一个时间点上只会有一个程序执行，而后来到了多核的CPU，那么即使有再多的进程出现，也可以比单核CPU的处理速度有所提升。

线程概念

线程是在进程的基础上划分的更小的程序单元，线程是在进程基础上创建并使用的，所以线程依赖于进程的支持，但是线程的启动速度要比进程快很多，所以当使用多线程进行并发处理的时候，其执行的性能要高于进程。

Java是多线程的编程语言，所以Java在进行并发处理的时候可以得到更高的处理性能。

Thread类实现多线程

如果想要在java种实现多线程的定义，那么就需要一个专门的主体类进行线程的执行任务的定义，而这个主体类的定义是有要求的，必须实现特定的接口或者继承特定的父类才可以完成。

Java里面提供了一个Java.lang.Thread的程序类，那么一个类只要继承了此类，就表示这个类为线程的主体类。但并不是说就可以直接实现多线程处理了，还需要覆写Thread中提供的一个run方法，而这个方法就属于线程的主方法。

多线程要执行的功能都应该在run方法中进行定义。需要说明的是：在正常情况下如果想要执行一个类中的方法，那么肯定要产生实例化对象，而后去调用类中提供的方法，但是run方法是不能够直接调用的，因为这里面牵扯到一个操作系统的资源调度问题，所以想要启动多线程必须使用start方法完成。

class MyThread extends Thread{//线程主体类
    private String title;
    public MyThread(String title){
        this.title=title;
    }

    @Override
    public void run() {//线程的主体方法
        for (int i = 0; i < 10; i++) {
            System.out.println(this.title+"运行，x="+i);
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        new MyThread("线程A").start();
        new MyThread("线程B").start();
        new MyThread("线程C").start();
    }
}

为什么多线程的使用不直接使用run方法，而是必须使用Thread类中的start（）方法

观察源代码：

public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0) //判断线程的状态
            throw new IllegalThreadStateException();//抛出一个异常

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();

发现start()方法中会抛出一个IllegalThreadStateException()异常对象，但是整个程序并没有使用throws或者try catch处理，因为改异常一定是RuntimeException的子类，每一个线程类的对象只允许启动一次，如果重复启动则会抛出此异常。

在java程序执行的过程之中考虑到对于不同层次开发者的需求，所以其支持有本地的操作系统函数调用，而这项技术就被称为JNI(Java Native Interface)技术，但是Java开发之中并不推荐这样使用，利用这项技术可以使用一些操作系统提供底层函数进行一些特殊的处理，而在Thread类里提供的start0()就表示需要将此方法依赖于不同的操作系统实现。

Thread的执行分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0psuA7du-1679905010824)(…\img\thread.jpg)]

任何情况下，只要定义了多线程，多线程的启动永远只有一种方法：Thread类中的start()方法。

Runnable接口实现多线程

虽然可以通过Thread类的继承来实现多线程的定义，但是在Java程序里面对于继承永远都是存在有单继承局限的，所以在java里又提供有第二种多线程的主体定义结构形式，实现java.lang.Runnable接口，此接口的定义如下：

@FunctionalInterface //从JDK1.8引入了Lambda表达式之后就变为了函数式接口
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

但是由于此时不再继承Thread父类，那么对于此时的MyThread类中也就不再支持有start()这个继承的方法，可是如果不使用Thread.start()是无法进行多线程的启动的，那么就需要观察一下Thread类提供的构造方法。

public Thread(Runnable target)

class MyThread implements Runnable{//线程主体类
    private String title;
    public MyThread(String title){
        this.title=title;
    }

    @Override
    public void run() {//线程的主体方法
        for (int i = 0; i < 10; i++) {
            System.out.println(this.title+"运行，x="+i);
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        new Thread(new MyThread("线程对象A")).start();
        new Thread(new MyThread("线程对象B")).start();
        new Thread(new MyThread("线程对象C")).start();
    }
}

由于只是实现了Runnable接口对象，所以线程主体类上就不再有单继承局限了，这样的在设计才是一个标准型的设计。

从JDK1.8开始，Runnable接口使用了函数式接口定义，所以也可以直接利用Lambda实现多线程定义。

 public static void main(String[] args) {
        for(int x=0;x<3;x++){
            String title="线程对象"+x;
            Runnable run=()->{
                for (int i = 0; i < 10; i++) {
                    System.out.println(title+"运行、i="+i);
                }

            };
            new Thread(run).start();
        }
    }

在以后的开发之中对于多线程的实现，优先考虑Runnable接口实现，并且永恒都是通过Thread类对象启动多线程。

Thread和Runnable关系

在实现多线程的过程中，从代码的本身结构来讲Runnable是最方便的，因为其可以避免单继承的局限，同时也可以更好地进行功能的扩充。

但是从结构上观察Thread和Runnable的联系，打开Thread类的定义：

public class Thread extends Object implements Runnable{}

Thread类也是Runnable接口的子类，那么之前继承Thread类的时候实际上覆写的还是Runnable接口的run()方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2z9TSUmr-1679905010825)(…\img\runnable.jpg)]

多线程设计之中使用了代理设计模式的结构，用户自定义的线程主体只负责项目核心功能的实现，而所有的辅助实现全部由Thread类来处理。

在进行Thread启动多线程的时候调用的是start()方法，而后面调用的是run方法。

但通过Thread类的构造方法传递了一个Runnable接口对象的时候，那么该结构对象将被Thread类中的target属性保存，在start()方法执行的时候会调用Thread类中的run()方法，而这个run()方法去调用Runnable接口子类被覆写过的run方法。

多线程开发的实质是在于多个线程可以进行同一资源的抢占，那么Thread主要描述的是线程，而资源的描述是通过

Runnable完成的。

利用卖票程序来实现多个线程的资源并发访问：

class MyThread implements Runnable{//线程主体类
    private int  ticket=5;
    @Override
    public void run() {//线程的主体方法
        for (int i = 0; i < 100; i++) {
            if(this.ticket>0){
                System.out.println("卖票，ticket="+ticket--);
            }
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
    }
}
/**执行结果：
卖票，ticket=5
卖票，ticket=2
卖票，ticket=1
卖票，ticket=3
卖票，ticket=4**/

从内存分析图来分析本程序的执行结构：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-75pKzYfl-1679905010826)(…\img\ticket.jpg)]

Callable接口实现多线程

从传统开发来讲如果要实现多线程首选Runnable,但是Runnable接口有一个缺点：当线程执行完毕后无法获得一个返回值，所以JDK1.5之后提出了一个新的线程实现接口：java.util.concurrent.Callable接口。

接口的定义：

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

可以发现Callabable定义的时候可以设置一个泛型，此泛型的类型就是返回数据的类型，这样的好处时可以避免向下转型带来的安全隐患。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oOjwrG1A-1679905010827)(D:\笔记\markdown\Java基础\img\Callable.jpg)]

使用Callable接口实现多线程处理：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class MyThread implements Callable {//线程主体类

    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println("线程执行，i="+i);
        }
        return "线程执行完毕";
    }
}
public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask task = new FutureTask<>(new MyThread());
        new Thread(task).start();
        System.out.println("线程返回数据"+task.get());
    }
}

【Runnable接口和Callable接口的区别】

1. Runnable是在JDK1.0的时候提出的多线程实现接口，而Callable是在JDK1.5之后提出的。
2. Runnable接口中只提供了一个run()方法，并且没有返回值。
3. Callable提供有call方法，可以有返回值。

多线程运行状态

对于多线程的开发而言，编写程序的过程总是按照：定义线程主体类，而后通过Thread类进行线程的启动，但并不意味着调用了start()方法，线程就已经开始运行了，因为整体的线程处理有自己的一套运行的状态。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kk3Dm9Xs-1679905010828)(…\img\threadState.jpg)]

任何一个线程对象都应该使用Thread类进行封装，所有线程的启动使用的是start()方法，但是启动的时候实际上若干进程都将进入到一种就绪状态，现在并没有执行。
进入到就绪状态后就需要等待进行资源的调度，当某一个线程调度成功之后则会进入运行状态（run()方法），但是多有的进程不可能一直持续执行下去，中间需要产生一些暂停的状态，例如：某一个线程执行一段时间之后就需要让出资源，而后这个进程就进入到阻塞状态随后重新回归到就绪状态。
因为整体的线程处理有自己的一套运行的状态。

[外链图片转存中…(img-kk3Dm9Xs-1679905010828)]

任何一个线程对象都应该使用Thread类进行封装，所有线程的启动使用的是start()方法，但是启动的时候实际上若干进程都将进入到一种就绪状态，现在并没有执行。
进入到就绪状态后就需要等待进行资源的调度，当某一个线程调度成功之后则会进入运行状态（run()方法），但是多有的进程不可能一直持续执行下去，中间需要产生一些暂停的状态，例如：某一个线程执行一段时间之后就需要让出资源，而后这个进程就进入到阻塞状态随后重新回归到就绪状态。
当run()方法执行完毕之后，实际上该线程的主要任务也就结束了，那么此时可以直接进入到停止状态。