java多线程并发编程_java线程实现的三种方式

java多线程并发编程_java线程实现的三种方式Java并发编程:Java创建线程的三种方式

大家好,又见面了,我是你们的朋友全栈君。

引言

在日常开发工作中,多线程开发可以说是必备技能,好的程序员是一定要对线程这块有深入了解的,我是Java程序员,并且Java语言本身对于线程开发的支持是非常成熟的,所以今天我们就来入个门,学一下Java怎么创建线程。

创建线程的三种方式

Java创建线程主要有三种方式:

1、继承Thread类

2、实现Runnable接口

3、使用Callable和Future创建线程

下面分别讨论这三种方法的实现方式,以及它们之间的对比。

一、继承Thread类

步骤:

1、创建一个线程子类继承Thread类

2、重写run() 方法,把需要线程执行的程序放入run方法,线程启动后方法里的程序就会运行

2、创建该类的实例,并调用对象的start()方法启动线程

示例代码如下:

public class ThreadDemo extends Thread{
    @Override
    public void run() {
        super.run();
        System.out.println("需要运行的程序。。。。。。。。");
    }

    public static void main(String[] args) {
        Thread thread = new ThreadDemo();
        thread.start();
    }
}
复制代码

当运行main方法后,程序就会执行run()方法里面的内容,执行完之后,线程也就随之消亡,为什么一定要重写run()方法呢?

点击方法的源码后,发现Thread的run()方法其实什么都没有做

public void run() {
    if (target != null) {
        target.run();
    }
}

public abstract void run();
复制代码

如果run()里没有需要运行的程序,那么线程启动后就直接消亡了。想让线程做点什么就必须重写run()方法。同时,还需要注意的是,线程启动需要调用start()方法,但直接调用run() 方法也能编译通过,也能正常运行:

public static void main(String[] args) {
    Thread thread = new ThreadDemo();
    thread.run();
}
复制代码

只是这样是普通的方法调用,并没有新起一个线程,也就失去了线程本身的意义。

二、实现Runnable接口

1、定义一个线程类实现Runnable接口,并重写该接口的run()方法,方法中依然是包含指定执行的程序。

2、创建一个Runnable实现类实例,将其作为target参数传入,并创建Thread类实例。

3、调用Thread类实例的start()方法启动线程。

public class RunnableDemo implements Runnable{
    @Override
    public void run() {
        System.out.println("我是Runnable接口......");
    }
    public static void main(String[] args) {

        RunnableDemo demo = new RunnableDemo();
        Thread thread = new Thread(demo);
        thread.start();
    }
}
复制代码

这是基于接口的方式,比起继承Thread的方式要灵活很多,但需要多创建一个线程对象,打开源码可以发现,当把Runnable实现类的实例作为参数target传入后,赋值给当前线程类的target,而run()里执行的程序就是赋值进去的target的run()方法。

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
                      
        ...........这里省略部分源码..........
        
        this.target = target;
        setPriority(priority);
        if (parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;

        /* Set thread ID */
        tid = nextThreadID();
    }
    
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
复制代码

三、使用Callable和Future创建线程

使用Callable创建线程和Runnable接口方式创建线程比较相似,不同的是,Callable接口提供了一个call() 方法作为线程执行体,而Runnable接口提供的是run()方法,同时,call()方法可以有返回值,而且需要用FutureTask类来包装Callable对象。

public interface Callable<V> {
    
    V call() throws Exception;
}
复制代码

步骤:

1、创建Callable接口的实现类,实现call() 方法

2、创建Callable实现类实例,通过FutureTask类来包装Callable对象,该对象封装了Callable对象的call()方法的返回值。

3、将创建的FutureTask对象作为target参数传入,创建Thread线程实例并启动新线程。

4、调用FutureTask对象的get方法获取返回值。

public class CallableDemo implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int i = 1;
        return i;
    }

    public static void main(String[] args) {
        CallableDemo demo = new CallableDemo();
        FutureTask<Integer> task = new FutureTask<Integer>(demo);

        new Thread(task).start();
        try {

            System.out.println("task 返回值为:" + task.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
复制代码

执行main方法后,程序输出如下结果:

task 返回值为:1
复制代码

说明,task.get()确实返回了call() 方法的结果。那么其内部是怎么实现的呢。先打开FutureTask的构造方法,可以看到其内部是将Callable对象作为参数传递给当前实例的Callable成员,

public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}

复制代码

同时,将成员变量state置为NEW,当启动task后,其run方法就会执行Callable的call()方法,

public void run() {
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
            	//把call()的返回结果复制给result
                result = c.call();
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                setException(ex);
            }
            if (ran)
            	//将结果设置给其他变量
                set(result);
        }
    } finally {
        // runner must be non-null until state is settled to
        // prevent concurrent calls to run()
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        int s = state;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}
protected void set(V v) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        	//把传过来的值赋值给outcome成员
            outcome = v;
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
            finishCompletion();
        }
    }
复制代码

run()方法中经过一系列的程序运行后,把call()的返回结果赋值给了outcome,然后当调用task.get()方法里获取的就是outcome的值了,这样一来,也就顺理成章的得到了返回结果。

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    return report(s);
}
private V report(int s) throws ExecutionException {
        Object x = outcome;
        if (s == NORMAL)
        	//返回outcome的值
            return (V)x;
        if (s >= CANCELLED)
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);
    }
复制代码

可以看出,源码的运行逻辑还是比较清晰的,代码也比较容易理解,所以,我比较建议读者们有空可以多看看Java底层的源码,这样能帮助我们深入的理解功能是怎么实现的。

三种方式的对比

好了,创建线程的三种方式实例都说完了,接下来说下他们的对比。

从实现方式来说,使用Runnable接口和Callable接口的方式基本相同,区分的只是Callable实现的方法体可以有返回值,而继承Thread类是使用继承方式,所以,其实三种方法归为两类来分析即可。

1、使用继承Thread类的方式:

  • 优势:编码简单,并且,当需要获取当前线程,可以直接用this
  • 劣势:由于Java支持单继承,所以继承Thread后就不能继承其他父类

2、使用Runnable接口和Callable接口的方式:

  • 优势:

比较灵活,线程只是实现接口,还可以继承其他父类。

这种方式下,多个线程可以共享一个target对象,非常适合多线程处理同一份资源的情形。

Callable接口的方式还能获取返回值。

  • 劣势:

编码稍微复杂了点,需要创建更多对象。

如果想访问当前线程,需要用Thread.currentThread()方法。

总的来说,两种分类都有各自的优劣势,但其实后者的劣势相对优势来说不值一提,一般情况下,还是建议直接用接口的方式来创建线程,毕竟单一继承的劣势还是比较大的。

转载于:https://juejin.im/post/5c2435f1e51d4558873c59d7

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/107116.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • oracle锁表_数据库锁表如何解决

    oracle锁表_数据库锁表如何解决1、执行以下语句可查询被锁的表selectb.owner,b.object_name,a.session_id,a.locked_modefromv$locked_objecta,dba_objectsbwhereb.object_id=a.object_id;2、执行以下语句可查询被锁的session和serialselectb.username,b.sid,b.serial#,logon_timefromv$locked_objecta,v$session.

  • pycharm中如何导入库_pycharm怎么加入库

    pycharm中如何导入库_pycharm怎么加入库两种方法:1.搜索添加列表中是已经存在的库,若需要添加库,点击+搜索待库安装完成,即可使用2.利用终端命令输入代码,回车,即可完成(numpy库为例,我的是已经存在了)

  • JWT单点登录 看这一篇就够了!

    JWT单点登录 看这一篇就够了!JWT单点登录前言两种登录状态有状态登录无状态登录无状态登录流程整个登录过程中,最关键的点是什么?jwt实现无状态登录数据格式JWT交互流程非对称加密代码实现核心依赖核心工具类JWT工具类RSA工具类测试前言本编在某度上看到了很多关于JWT的实现,但是由于里面讲的太过详细和繁琐,所以打算自己出一篇,有什么不足之处,还希望多多提出来,觉得好的可以点个关注,不喜勿喷,祝猿们天天开心O(∩_∩)O~两种登录状态有状态登录为了保证客户端cookie的安全性,服务端需要记录每次会话的客户端信息,从而识别客户

  • filezilla server中文版使用教程_filezilla安装步骤

    filezilla server中文版使用教程_filezilla安装步骤filezillaserver下载、安装、配置教程下载filezillaserver安装filezillaserverFileZillaServer的配置教程下载filezillaserverfilezillaserver官网:FileZilla-ThefreeFTPsolution:https://filezilla-project.org/安装filezill……………

  • 代码注册广播需要调用registerReceiver()方法_怎么把程序注册成服务

    代码注册广播需要调用registerReceiver()方法_怎么把程序注册成服务分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&

  • List转JSONArray、JSONArray转List、String转JSONArray

    List转JSONArray、JSONArray转List、String转JSONArray1.List转JSONArrayList<T>list=newArrayList<T>();JSONArrayarray=JSONArray.parseArray(JSON.toJSONString(list));2.JSONArray转ListJSONArrayarray=newJSONArray();List<EventColAttr>list=JSONObject.parseArray(array.toJSONStri

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号