引言

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

创建线程的三种方式

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

1、继承Thread类

2、实现Runnable接口

3、使用Callable和Future创建线程

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

一、继承Thread类

步骤:

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

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

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

示例代码如下:

  1. public class ThreadDemo extends Thread{
  2. @Override
  3. public void run() {
  4. super.run();
  5. System.out.println("需要运行的程序。。。。。。。。");
  6. }
  7. public static void main(String[] args) {
  8. Thread thread = new ThreadDemo();
  9. thread.start();
  10. }
  11. }

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

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

  1. public void run() {
  2. if (target != null) {
  3. target.run();
  4. }
  5. }
  6. public abstract void run();

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

  1. public static void main(String[] args) {
  2. Thread thread = new ThreadDemo();
  3. thread.run();
  4. }

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

二、实现Runnable接口

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

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

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

  1. public class RunnableDemo implements Runnable{
  2. @Override
  3. public void run() {
  4. System.out.println("我是Runnable接口......");
  5. }
  6. public static void main(String[] args) {
  7. RunnableDemo demo = new RunnableDemo();
  8. Thread thread = new Thread(demo);
  9. thread.start();
  10. }
  11. }

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

  1. public Thread(Runnable target) {
  2. init(null, target, "Thread-" + nextThreadNum(), 0);
  3. }
  4. private void init(ThreadGroup g, Runnable target, String name,
  5. long stackSize, AccessControlContext acc) {
  6. ...........这里省略部分源码..........
  7. this.target = target;
  8. setPriority(priority);
  9. if (parent.inheritableThreadLocals != null)
  10. this.inheritableThreadLocals =
  11. ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
  12. /* Stash the specified stack size in case the VM cares */
  13. this.stackSize = stackSize;
  14. /* Set thread ID */
  15. tid = nextThreadID();
  16. }
  17. @Override
  18. public void run() {
  19. if (target != null) {
  20. target.run();
  21. }
  22. }

三、使用Callable和Future创建线程

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

  1. public interface Callable<V> {
  2. V call() throws Exception;
  3. }

步骤:

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

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

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

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

  1. public class CallableDemo implements Callable<Integer> {
  2. @Override
  3. public Integer call() throws Exception {
  4. int i = 1;
  5. return i;
  6. }
  7. public static void main(String[] args) {
  8. CallableDemo demo = new CallableDemo();
  9. FutureTask<Integer> task = new FutureTask<Integer>(demo);
  10. new Thread(task).start();
  11. try {
  12. System.out.println("task 返回值为:" + task.get());
  13. } catch (Exception e) {
  14. e.printStackTrace();
  15. }
  16. }
  17. }

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

  1. task 返回值为:1

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

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

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

  1. public void run() {
  2. if (state != NEW ||
  3. !UNSAFE.compareAndSwapObject(this, runnerOffset,
  4. null, Thread.currentThread()))
  5. return;
  6. try {
  7. Callable<V> c = callable;
  8. if (c != null && state == NEW) {
  9. V result;
  10. boolean ran;
  11. try {
  12. //把call()的返回结果复制给result
  13. result = c.call();
  14. ran = true;
  15. } catch (Throwable ex) {
  16. result = null;
  17. ran = false;
  18. setException(ex);
  19. }
  20. if (ran)
  21. //将结果设置给其他变量
  22. set(result);
  23. }
  24. } finally {
  25. // runner must be non-null until state is settled to
  26. // prevent concurrent calls to run()
  27. runner = null;
  28. // state must be re-read after nulling runner to prevent
  29. // leaked interrupts
  30. int s = state;
  31. if (s >= INTERRUPTING)
  32. handlePossibleCancellationInterrupt(s);
  33. }
  34. }
  35. protected void set(V v) {
  36. if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
  37. //把传过来的值赋值给outcome成员
  38. outcome = v;
  39. UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
  40. finishCompletion();
  41. }
  42. }

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

  1. public V get() throws InterruptedException, ExecutionException {
  2. int s = state;
  3. if (s <= COMPLETING)
  4. s = awaitDone(false, 0L);
  5. return report(s);
  6. }
  7. private V report(int s) throws ExecutionException {
  8. Object x = outcome;
  9. if (s == NORMAL)
  10. //返回outcome的值
  11. return (V)x;
  12. if (s >= CANCELLED)
  13. throw new CancellationException();
  14. throw new ExecutionException((Throwable)x);
  15. }

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

三种方式的对比

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

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

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

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

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

  • 优势:

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

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

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

  • 劣势:

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

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

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

Java并发编程:Java创建线程的三种方式的更多相关文章

  1. 0036 Java学习笔记-多线程-创建线程的三种方式

    创建线程 创建线程的三种方式: 继承java.lang.Thread 实现java.lang.Runnable接口 实现java.util.concurrent.Callable接口 所有的线程对象都 ...

  2. JAVA并发编程学习笔记------线程的三种创建方式

    创建线程一般有如下几个方式: 1. 通过继承Thread类来创建一个线程: /** * 步骤1:定义一个继承Thread类的子类 * 步骤2:构造子类的一个对象 * 步骤3:启动线程: * */ pu ...

  3. java创建线程的三种方式及其对比

    第一种方法:继承Thread类,重写run()方法,run()方法代表线程要执行的任务.第二种方法:实现Runnable接口,重写run()方法,run()方法代表线程要执行的任务.第三种方法:实现c ...

  4. AJPFX总结java创建线程的三种方式及其对比

    Java中创建线程主要有三种方式: 一.继承Thread类创建线程类 (1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务.因此把run()方法称为执行 ...

  5. java创建线程的三种方式及其对照

    Java中创建线程主要有三种方式: 一.继承Thread类创建线程类 (1)定义Thread类的子类.并重写该类的run方法,该run方法的方法体就代表了线程要完毕的任务.因此把run()方法称为运行 ...

  6. Java中创建线程的三种方式以及区别

    在java中如果要创建线程的话,一般有3种方法: 继承Thread类: 实现Runnable接口: 使用Callable和Future创建线程. 1. 继承Thread类 继承Thread类的话,必须 ...

  7. python 并发编程 多线程 开启线程的两种方式

    一 threading模块介绍 multiprocess模块的完全模仿了threading模块的接口,二者在使用层面,有很大的相似性 二 开启线程的两种方式 第一种 每造一个进程,默认有一个线程,就是 ...

  8. Java多线程之创建线程的三种方式比较

    转载请注明原文地址:http://www.cnblogs.com/ygj0930/p/6560057.html  一:继承Thread类创建线程 1:继承Thread类定义线程子类: 2:重写run( ...

  9. Java创建线程的三种方式

    一.继承Thread类创建线程类 (1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务.因此把run()方法称为执行体. (2)创建Thread子类的实 ...

随机推荐

  1. hive、sqoop、MySQL间的数据传递

    hdfs到MySQL csv/txt文件到hdfs MySQL到hdfs  hive与hdfs的映射: drop table if exists emp;create table emp ( id i ...

  2. Codeforces Round #486 (Div. 3) F. Rain and Umbrellas

    Codeforces Round #486 (Div. 3) F. Rain and Umbrellas 题目连接: http://codeforces.com/group/T0ITBvoeEx/co ...

  3. Paper | Contrast Limited Adaptive Histogram Equalization

    目录 1. 背景 1.1. 对比度和直方图均衡HE 1.2. HE的问题 1.3. AHE 1.4. 底噪问题 2. CLAHE 2.1. 效果展示 2.2. 算法格式和细节 论文:Contrast ...

  4. centos下安装nethogs

    wget https://github.com/raboof/nethogs/archive/v0.8.1.tar.gzyum install libpcap-develtar zxvf v0.8.1 ...

  5. Hessian 使用例子

    一.协议包(数据对象需要实现序列化接口,可以用于服务端接口.客户端调用服务之用) /** * */ package com.junge.demo.protocol.model; import java ...

  6. zookeeper日志级别

    查看源代码得知zookeeper(版本3.4.13)内部的日志用的slf4j,项目启动zk连接了之后一直在打debug日志(如下所示),甚是讨厌,logback日志级别调成info没用. 17:24: ...

  7. i春秋SRC部落携手同程SRC发布首届漏洞提交任务

    [部落守卫者集结令]拿巨额奖金?上白帽子排行榜?近距离膜拜大佬?学技术?掌握窍门?又或者你是个责任感爆棚想要互联网行业安全的有志青年?加入i春秋部落守卫者(The Guarders),统统满足你! [ ...

  8. Android框架式编程之MVP架构

    MVP(Model-View-Presenter)模式.是将APP的结构分为三层:View - Presenter - Model. View 1. 提供UI交互 2. 在presenter的控制下修 ...

  9. Java 大数值类型执行精确计算

    简介 如果基本的整数和浮点数精度不能够满足需求,那么可以使用 java.math 包下两个很有用的类:BigInteger 和 BigDecimal.这两个类可以处理包含任意长度数字序列的数值,Big ...

  10. openresty + lua 1、openresty 连接 mysql,实现 crud

    最近开发一个项目,公司使用的是 openresty + lua,所以就研究了 openresty + lua.介绍的话,我就不多说了,网上太多了. 写这个博客主要是记录一下,在学习的过程中遇到的一些坑 ...