关于java:这几种实现线程的方法你一定要知道月薪20k以上的面试都会问到

42次阅读

共计 4547 个字符,预计需要花费 12 分钟才能阅读完成。

实现线程的三种形式总结

最近有看到 Java 线程的实现相干问题,在此对线程实现形式做一个小小的总结,当做笔记,便于日后查看。

平时罕用的线程形式有三种:

(1)、继承 Thread 类,并重写其 run() 办法。

(2)、实现 Runnable 接口,并实现其 run() 办法。

(3)、实现 Callable 接口,并实现其 call() 办法。

一、继承 Thread 类

Thread 类中创立线程最重要的两个办法为:

    public void start();
    public void run();

采纳 Thread 类创立线程,用户只须要继承 Thread,笼罩 Thread 中的 run 办法,父类 Thread 中的 run 办法没有抛出异样,那么子类也不能抛出异样,最初采纳 start 启动线程即可。

【示例代码 1】不应用线程

public class ThreadTest01 {public static void main(String[] args) {Processor p = new Processor();
        p.run();
        method1();}
    
    private static void method1() {System.out.println("--------method1()----------");
    }
}
class Processor {public void run() {for (int i=0; i<10; i++) {System.out.println(i);
        }
    }
}

【执行后果】

0
1
2
3
4
5
6
7
8
9
--------method1()----------

以上程序输入相应的后果(属于串行),也就是 run 办法齐全执行实现后,才执行 method1 办法,也就是 method1 必须期待后面的办法返回才能够失去执行,这是一种“同步编程模型”。

这样执行存在什么样的弊病呢?

依照程序执行,这就极大的升高了程序的执行效率。无奈同时执行多个代码片段,这也是多线程并发所要达到的目标。

【示例代码 2】应用线程

public class ThreadTest02 {public static void main(String[] args) {Processor p = new Processor();
        /*
            如果是手动调用该办法,
            则并不能采纳 run 来启动一个场景(线程),run 就是一个一般办法调用。*/
        //p.run();
        
        /*
            采纳 start 启动线程,不是间接调用 run,
            start 不是马上执行线程,而是使线程进入就绪状态
            线程的真正执行是由 Java 的线程调度机制实现的。*/
        p.start();
        
        // 线程只能启动一次,无奈启动屡次
        //p.start();
        
        method1();}
    
    private static void method1() {System.out.println("--------method1()----------");
    }
}
class Processor extends Thread {
    /*
        笼罩 Thread 中的 run 办法,该办法没有异样
        该办法是由 java 线程调度机制调用的, 因而
        咱们不应该手动调用该办法
    */
    public void run() {for (int i=0; i<10; i++) {System.out.println(i);
        }
    }
}

【执行后果】

--------method1()----------
0
1
2
3
4
5
6
7
8
9

通过输入后果大家会看到,没有依照程序执行,而在输入数字的同时执行了 method1() 办法,如果从效率上看,采纳多线程的示例要快些,因为咱们能够看作他是同时执行的,mthod1() 办法没有期待后面的操作实现才执行,这叫“异步编程模型”。

那么,为什么会是这样的执行后果呢?

这就波及到 Java 线程的调度机制了,该程序蕴含两个线程一个是主线程也就是 main 线程,另外一个是用户创立的 p 线程,当类加载实现后,主线程启动,开始执行 main 办法栈帧,依照代码自上而下的执行程序,先创立 Processor 的实例化对象 p,接着是执行 p.start(); 启动 p 线程,这时 method1();办法还没有执行,此时两个线程均曾经启动,依照 Java 线程调度的规定,两个线程开始争夺执行程序的工夫片(即 CPU 的执行权),留神,这种争夺是随机的,也就是说,不肯定输入后果就是 method1 办法先执行,for 循环语句后执行。能够多执行几次即可看到不一样的执行后果。

二、实现 Runnable 接口

其实 Thread 对象自身就实现了 Runnable 接口,但个别倡议间接应用 Runnable 接口来写多线程程序,因为接口会比类带来更多的益处(面向接口编程的准则)。

【示例代码 3】

public class ThreadTest03 {public static void main(String[] args) {//Processor r1 = new Processor();
        /*
            应用多态机制父类型援用指向子类型对象,
            因为这样能够调用 Runnable 接口的办法
        */
        Runnable r1 = new Processor();
        
        // 不能间接调用 run 办法, 起因见上文
        //p.run();
        
        // 创立线程对象,并将 r1 对象作为参数传入(Thread 的构造方法)Thread t1 = new Thread(r1);
        
        // 启动线程
        t1.start();
        
        method1();}
    
    private static void method1() {System.out.println("--------method1()----------");
    }
}
// 实现 Runnable 接口
class Processor implements Runnable {
    // 实现 Runnable 中的 run 办法
    public void run() {for (int i=0; i<10; i++) {System.out.println(i);
        }
    }
}

【执行后果】

--------method1()----------
0
1
2
3
4
5
6
7
8
9

后果剖析见上,起因是一样的,只不过是换了一种形式实现线程而已。

三、实现 Callable 接口

察看上文两种线程的执行形式,存在什么毛病。显然,以上两种线程的执行 un 办法时是没有返回值的,而实际上也会存在须要失去线程执行的返回后果的状况,那么怎么办呢?这时就能够思考应用第三种线程的实现形式。

长处:能够获取到线程的执行后果。
毛病:效率比拟低,在获取 t 线程执行后果的时候,以后线程受阻塞,效率较低。

【示例代码 4 -1】应用匿名外部类

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

public class ThreadTest04 {public static void main(String[] args) throws Exception {
        // 第一步:创立一个“将来工作类”对象。// 参数十分重要,须要给一个 Callable 接口实现类对象。FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception { // call() 办法就相当于 run 办法。只不过这个有返回值
                // 线程执行一个工作,执行之后可能会有一个执行后果
                // 模仿执行
                System.out.println("call method begin");
                Thread.sleep(1000 * 10);// 以后线程睡眠 10 秒
                System.out.println("call method end!");
                int a = 100;
                int b = 200;
                return a + b; // 主动装箱 (300 后果变成 Integer)
            }
        });

        // 创立线程对象
        Thread t = new Thread(task);

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

        // 这里是 main 办法,这是在主线程中。// 在主线程中,怎么获取 t 线程的返回后果?// get() 办法的执行会导致“以后线程阻塞”Object obj = task.get();
        System.out.println("线程执行后果:" + obj);

        // main 办法这里的程序要想执行必须期待 get() 办法的完结
        // 而 get() 办法可能须要很久。因为 get() 办法是为了拿另一个线程的执行后果
        // 另一个线程执行是须要工夫的。System.out.println("hello world!");
    }
}

【执行后果】

call method begin
call method end!
线程执行后果:300
hello world!

【示例代码 4 -2】不应用匿名外部类

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

public class ThreadTest01 {public static void main(String[] args) throws Exception {
        // 创立 Callable 接口的实现类的实例化对象
        CallableImpl callable = new CallableImpl();

        // 第一步:创立一个“将来工作类”对象。// 参数十分重要,须要给一个 Callable 接口实现类对象。FutureTask task = new FutureTask(callable);

        // 创立线程对象
        Thread t = new Thread(task);

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

        // 这里是 main 办法,这是在主线程中。// 在主线程中,怎么获取 t 线程的返回后果?// get() 办法的执行会导致“以后线程阻塞”Object obj = task.get();
        System.out.println("线程执行后果:" + obj);

        // main 办法这里的程序要想执行必须期待 get() 办法的完结
        // 而 get() 办法可能须要很久。因为 get() 办法是为了拿另一个线程的执行后果
        // 另一个线程执行是须要工夫的。System.out.println("hello world!");
    }
}
// 实现 Callable 接口
class CallableImpl implements Callable{
    @Override
    public Object call() throws Exception { // call() 办法就相当于 run 办法。只不过这个有返回值
        // 线程执行一个工作,执行之后可能会有一个执行后果
        // 模仿执行
        System.out.println("call method begin");
        Thread.sleep(1000 * 10);// 以后线程睡眠 10 秒
        System.out.println("call method end!");
        int a = 100;
        int b = 200;
        return a + b; // 主动装箱 (300 后果变成 Integer)
    }
}

【执行后果】

call method begin
call method end!
线程执行后果:300
hello world!

最初

谢谢你的观看,感觉文章对你有帮忙的话记得关注我点个赞反对一下!也欢送大家关注我的公众号: 前程有光 ,金三银四跳槽面试季,整顿了 1000 多道将近 500 多页 pdf 文档的 Java 面试题材料,每天都会分享 java 相干技术文章或行业资讯,整顿的材料也会放在外面。

正文完
 0