精华内容
下载资源
问答
  • 在本文里我们通过实例给大家讲解了JAVA开启线程的方法和相关知识点,需要的朋友们跟着学习下。
  • Java有几种方法开启线程?怎么实现带有返回值线程?发布时间:2020-05-22 11:20:08来源:亿速云阅读:238作者:LeahJava有几种方法开启线程?怎么实现带有返回值线程?这些问题可能是我们日常工作会见到。通过...

    Java有几种方法开启线程?怎么实现带有返回值的线程?

    发布时间:2020-05-22 11:20:08

    来源:亿速云

    阅读:238

    作者:Leah

    Java有几种方法开启线程?怎么实现带有返回值的线程?这些问题可能是我们日常工作会见到的。通过这些问题,希望你能收获更多。下面是揭开这些问题的详细内容。

    一:无返回值类型的

    1:继承Thread类

    2:实现Runnable接口

    这两种是大家常用的,代码demo就截图吧。

    1:继承Thread类的写法

    定义:一个类型需要extends thread类,然后实现thread类的run方法。

    e3075027415378fc9573ff35898ceeff.png

    编辑

    2:实现Runnable接口的写法:

    定义一个类,实现Runable接口,重新run方法。

    New个thread对象,使用有参构造器,参数是runnable的。然后thread.start()

    bf99e60b2f970b7d97dc839cebfcc901.png

    编辑

    二:带有返回值的

    3:实现Callable接口

    操作步骤:

    一个类实现Callable接口,重新call方法;

    在调用的时候,需要使用FutureTask这个类的有参构造,然后再使用thread的有参构造。

    最后调用task的get方法。

    代码如下:

    9064f58fc93a132d6dbef4ff19b82cc0.png

    编辑

    运行结果:

    07ad2e59add4813a346859d62c3167a6.png

    编辑

    Callable返回值的源码:

    我们从FutureTask这个类入手,因为返回值就是从FutureTask中获取的。来看看类关系图:

    7d70cb21d168160a87dbb786ea18530c.png

    编辑

    FutureTask实现了RunnableFuture接口,RunnableFuture接口继承了Future和Runnable接口。

    d05cfe27af5bcdf1b2aa52a049eab6ec.png

    编辑

    8f3e156fcdfb275193405ee733471e36.png

    编辑

    我们看RunnableFuture这个接口的时候,发现只有一个无返回值的run方法。那么,线程返回的数据是哪个类实现的呢?其实就在FutureTask类里面。我们在来看看FuntrueTask这个类:

    cccbf9caacbd18a4ccb83e0289eb077a.png

    编辑

    重新了run方法。最后,有个set result。既然有set方法。在来看看demo中task.get()方法:

    0d3075c46d74b32d3874eb7d62427086.png

    编辑

    Get方法就带有返回值的。

    至此,实现callable接口带有返回值的原因已经找到了。

    4:使用线程池创建线程

    使用线程池创建的线程,可以有返回值,也可以没有返回值。使用Executory这个顶级接口来处理。

    我们先来看看Executor接口的关系。如下图:

    cc4aec2169cff2f154721ab80f7112be.png

    编辑

    其中看到了熟悉的ThreadPoolExecutor和ScheduledThreadPoolExecutor

    4.1:使用Executor创建没有返回值得线程:

    76886860be68c45d7937b887805b9f3b.png

    编辑

    说明:这里不带返回值的,其实就是调用了Runnable的run方法。

    4.2:带有返回值的demo

    创建一个类,实现Callable接口。如下图:

    15349c0a22fffb193ef411f986e32d70.png

    编辑

    通过这个接口,我们知道是有返回值的。

    c829568b03eced4b95693fd52497c565.png

    Java中实现线程有4种方式:

    我们最熟悉的不带换回值的两种以及带有返回值的两种。分别是:

    Thread、Runnable和Callable以及线程池

    关于开启java线程和实现带有返回值线程的方法就分享到这里了,希望以上内容可以对大家有一定的帮助,可以学到更多知识。如果喜欢这篇文章,不如把它分享出去让更多的人看到。

    展开全文
  • 有时候我们在使用java编程时候,想启动线程,怎么启动呢,下面来分享一下方法第一步在我们电脑上打开eclipse,创建一个java项目,并创建三个类,Test是测试Runnable类实现线程程序类,DoSomething是实现...

    有时候我们在使用java编程的时候,想启动线程,怎么启动呢,下面来分享一下方法

    第一步在我们的电脑上打开eclipse,创建一个java项目,并创建三个类,Test是测试Runnable类实现的多线程程序类,DoSomething是实现Runnable接口的多线程类,TestThread是测试继承Thread类实现的多线程程序类,如下图所示:

    763315a6bc663630ba24fecca7a4d9fc.png

    第二步我们首先看一下DoSomething类,实现了Runnable接口,成为线程类,并在run方法中进行双层循环打印姓名和数字,如下图所示:

    8d6fe8549dbeb8e8ac323665139c2d2b.png

    第三步我们在Test测试类中,通过Thread t1 = new Thread(ds1);代码创建线程对象, t1.start(); 启动线程,如下图所示:

    1e70d23d087653490e5a34c4c24f0cb7.png

    第四步我们运行Test测试类,可以看到控制台打印出了结果,需要注意的是启动线程只需要调用start方法就可以,java虚拟机会执行Runnable接口中的run()方法,如下图所示:

    40cd6eff3717828815949e2d84ac7b88.png

    方法二:启动继承Thread类实现的多线程

    第一步我们在TestThread类中继承Thread,成为线程类,重写run方法,在main方法中创建线程对象,通过 t1.start(); 进行启动线程,如下图所示:

    6dec2df4817d74265f43dff71fd6f517.png

    第二步我们运行TestThread类,可以看到打印台出现了与上面一样的结果,代表启动线程成功,需要注意的是for(long k= 0; k <100000000;k++);{}测试的是一个耗时操作,如下图所示:

    375dceb31c5c48023e9b438b56aeab85.png

    展开全文
  • 一、继承Thread类步骤:1):定义一个类A继承于Java.lang.Thread类.2):在A类中覆盖Thread类中run方法.3):我们在run方法中编写需要执行操作:run方法代码,线程执行体.4):在main方法(线程)中,创建线程对象,并启动...

    一、继承Thread类

    步骤:

    1):定义一个类A继承于Java.lang.Thread类.

    2):在A类中覆盖Thread类中的run方法.

    3):我们在run方法中编写需要执行的操作:run方法里的代码,线程执行体.

    4):在main方法(线程)中,创建线程对象,并启动线程:

    (1)创建线程类对象:                A类   a  =  new   A类();

    (2)调用线程对象的start方法:    a.start();//启动一个线程

    注意:千万不要调用run方法,如果调用run方法好比是对象调用方法,依然还是只有一个线程,并没有开启新的线程.

    线程只能启动一次!

    创建启动线程实例:

    //1):定义一个类A继承于java.lang.Thread类.

    class MusicThread extends Thread{

    private String idNum;

    public MusicThread(String idNum) {

    this.idNum= idNum;

    }

    //2):在A类中覆盖Thread类中的run方法.

    public void run() {

    //3):在run方法中编写需要执行的操作

    System.out.println(idNum);

    }

    }

    public class ExtendsThreadDemo {

    public static void main(String[] args) {

    //4):在main方法(线程)中,创建线程对象,并启动线程.

    MusicThread music = new MusicThread("123456");

    music.start();

    }

    }

    二、实现Runnable接口

    步骤:

    1):定义一个类A实现于java.lang.Runnable接口,注意A类不是线程类.

    2):在A类中覆盖Runnable接口中的run方法.

    3):我们在run方法中编写需要执行的操作:run方法里的,线程执行体.

    4):在main方法(线程)中,创建线程对象,并启动线程:

    (1)创建线程类对象:        Thread  t = new Thread(new  A());

    (2)调用线程对象的start方法:     t.start();

    创建启动线程实例:

    //1):定义一个类A实现于java.lang.Runnable接口,注意A类不是线程类.

    class MusicImplements implements Runnable{

    private String idNum;

    public void setId(String idNum){

    this.idNum = idNum;

    }

    //2):在A类中覆盖Runnable接口中的run方法.

    public void run() {

    //3):在run方法中编写需要执行的操作

    System.out.println(idNum);

    }

    }

    public class ImplementsRunnableDemo {

    public static void main(String[] args) {

    //4):在main方法(线程)中,创建线程对象,并启动线程

    MusicImplements mi = new MusicImplements();

    mi.setId("123456");

    Thread t = new Thread(mi);

    t.start();

    }

    }

    继承方式和实现方式的区别:

    继承方式:

    1):从设计上分析,Java中类是单继承的,如果继承了Thread了,该类就不能再有其他的直接父类了.

    2):从操作上分析,继承方式更简单,获取线程名字也简单.(操作上,更简单)

    String name = Thread.currentThread().getName();

    3):从多线程共享同一个资源上分析,继承方式不能做到.

    实现方式:

    1):从设计上分析,Java中类可以多实现接口,此时该类还可以继承其他类,并且还可以实现其他接口,设计更为合理.

    2):从操作上分析,实现方式稍微复杂点,获取线程名字也比较复杂,得使用Thread.currentThread()来获取当前线程的引用.

    3):从多线程共享同一个资源上分析,实现方式可以做到(是否共享同一个资源).

    来源:https://www.icode9.com/content-1-645651.html

    展开全文
  • JAVA-开启线程的方法

    2020-03-29 10:33:00
    继承Thread类,重写run方法 //1):定义一个类A继承于java.lang.Thread类. class MyThread extends Thread{ //构造函数给线程传递名称 public MyThread(String name){ super(name); } //无参构造函数(如果不写...

    继承Thread类,重写run方法

    class MyThread extends Thread{  
        //构造函数给线程传递名称
        public MyThread(String name){
             super(name);
        }
        //无参构造函数(如果不写构造函数默认有无参构造函数)
        public MyThread(){
             super();
        }
        public void run() {  
             //这里写要执行的代码
        }  
    }  
      
    public class Threadtest1 {  
        public static void main(String[] args) {  
            //创建自定义的线程对象,名称为m1,如果不需要名字,则类里面可以不写构造函数,下方构造MyThread对象也不需要传入参数   
            MyThread m = new MyThread("m1");
            m.strat();//使用start方法启动线程而不是run方法
        }  
    }
    

    实现Runnable接口,重写run方法

    public class MyThread2 implements Runnable{ 
    	public void run() {
    		//这里写要执行的代码
    	}
    }
    
    public class Threadtest2 {  
        public static void main(String[] args) {  
            //创建自定义类对象作为线程任务对象    
            MyThread2 mt = new MyThread2();  
            Thread m = new Thread(mt);
            //如果要为它定义名称,则传入第二个参数
            //Thread m = new Thread(mt,"自定义名称");
            m.strat();//使用start方法启动线程
        }  
    }
    

    匿名内部类

    上一种方式的变形

    public class Main {
    	
    	public static void main(String[] args) {
    		new Thread(new Runnable() {			
    			public void run() {
    			//要执行的代码
    			}
    	    }).start();
    	}
    }
    
    

    Thread类和Runnable接口的区别

    本人理解不深,参照大佬的理解。以后若是会深入用到,就回来填坑。

    参考链接:点这里

    萌新学习中,大佬见笑

    展开全文
  • 本文整理于网络 取众人所长1....①启动线程 ②调用当前线程的run()方法注意:千万不要调用run方法,如果调用run方法好比是对象调用方法,依然还是只有一个线程,并没有开启新的线程.线程只能启动一次!2.实现Runna...
  • java 开启线程的三种方法

    千次阅读 2019-06-13 13:33:47
    1 继承Thread类,重写run方法(不推荐,因为java的单继承局限性) package study_02; /* * 继承Thread类,重写run方法 * */ public class TestThread extends Thread{ @Override public void run() { for (int ...
  • 开启线程的三种方法0x01:继承 类,重写 方法,在方法体中编写要完成的任务0x02:实现接口,实现 方法,并把实现接口的对象作为target传入的构造方法启动线程0x03:实现接口,实现 方法,使用类来包装对象,使用对象作为...
  • 方式1:继承Thread类步骤:1):定义一个类A继承于Java.lang.Thread类.2):在A类中覆盖Thread类中run方法.3):我们在run方法中编写需要执行操作:run方法代码,线程执行体.4):在main方法(线程)中,创建线程对象,并...
  • 方式1:继承Thread类步骤:1):定义一个类A继承于Java.lang.Thread类.2):在A类中覆盖Thread类中run方法.3):我们在run方法中编写需要执行操作:run方法代码,线程执行体.4):在main方法(线程)中,创建线程对象,并...
  • 一、继承Thread类步骤:1):定义一个类A继承于Java.lang.Thread类.2):在A类中覆盖Thread类中run方法.3):我们在run方法中编写需要执行操作:run方法代码,线程执行体.4):在main方法(线程)中,创建线程对象,并启动...
  • java开启线程的三种方法

    万次阅读 2017-02-28 09:12:51
    见:http://blog.csdn.net/caidie_huang/article/details/52748460 见:http://blog.csdn.net/typename/article/details/7212512 方式1:继承Thread类 ...1):定义一个类A继承于Java.lang.Thread类. 2):在A类中
  • Java 开启线程的本质

    2021-01-17 10:26:17
    我们知道创建并启动线程, 直接方式是 new Thread() { public void run() { System.out.println("你好鸭"); } // 调用 start() 方法启动线程 }.start(); 查看该 start() 方法源代码 核心在调用了 start0() ...
  • java开启线程的两种方法 1.实现Runnable接口,重写run方法 2.继承Thread类,重写run方法 //继承Thread,缺点因为java只支持单继承,所以继承了Thread就无法继承别的类 public class MyThread extends Thread { @...
  • java开启线程的方法及优化

    千次阅读 2018-08-22 14:54:09
    1.new Thread弊端 执行一个异步任务你还只是如下new Thread吗? 1 2 3 4 5 6 7 new Thread(new Runnable() {    @Override  public void run() { ...
  • 主要介绍了Java开启线程并传参方法代码实现,文中通过示例代码介绍非常详细,对大家学习或者工作具有一定参考学习价值,需要朋友可以参考下
  • 一、区别Java中启动线程有两种方法,继承Thread类和实现Runnable接口...start方法:通过该方法启动线程的同时也创建了一个线程,真正实现了多线程。无需等待run()方法中的代码执行完毕,就可以接着执行下面的代码。...
  • public class runThread extends Thread{ @Override public void run() { ... System.out.println("重写run方法线程开启"); } } } public class runnableThread implements Runnable{ @Override public voi
  • /*join:当A线程执行到了B线程的.join()方法时,A就会等待。等B线程都执行完,A才会执行。join可以用来临时加入线程执行。1.线程使用join方法,主线程就停下,等它执行完,那么如果该线程冻结了,主线程就挂了,这也...
  • 方法 方法一:继承Thread类 ...3):我们在run方法中编写需要执行操作:run方法代码,线程执行体. 4):在main方法(线程)中,创建线程对象,并启动线程. (1)创建线程类对象: A类 a = new ...
  • 目录 继承Thread类 实现Runnable接口 通过Callable和Future创建对象 ... 调用线程对象start()方法类启动该线程 package com.cn.thread; /** * 1.定义Thread类子类,并重写run()方法 */ public...
  • 一、继承Thread类步骤:1):定义一个类A继承于Java.lang.Thread类.2):在A类中覆盖Thread类中run方法.3):我们在run方法中编写需要执行操作:run方法代码,线程执行体.4):在main方法(线程)中,创建线程对象,并启动...
  • 进程是静态,一个进程里可以有多个线程。起动线程有两个方法:一个是接口RUNABLE,一个是继承THERADpublic class testthread{public static void main(){Runner1 r = new Runner1();Thread t = new Thread(r);t....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,959
精华内容 783
关键字:

java开启线程的方法

java 订阅