精华内容
下载资源
问答
  • 这个问题一般会出现在面试当中,多线程创建有哪几种方式呢?答:实现Runable接口和实现Thread类。 我们先看看看实现这两种的实现方式 1 package com.summer; 2 3 public class ThreadA implements ...

    这个问题一般会出现在面试当中,多线程创建有哪几种方式呢?
    答:实现Runable接口和实现Thread类。

    我们先看看看实现这两种的实现方式

     1 package com.summer;
     2 
     3 public class ThreadA implements Runnable {
     4 
     5     public void run() {
     6         System.out.println("start ThreadA!");
     7     }
     8 
     9     public static void main(String[] args) {
    10         Thread thread = new Thread(new ThreadA());
    11         thread.start();
    12     }
    13 }

     

     1 package com.summer;
     2 
     3 public class ThreadB extends Thread {
     4 
     5     @Override
     6     public void run() {
     7         System.out.println("start ThreadB!");
     8     }
     9 
    10     public static void main(String[] args) {
    11         ThreadB threadB = new ThreadB();
    12         threadB.start();
    13     }
    14 }

     

    那么除了这两种方式以外还有什么其他方式呢?

    答:可以实现Callable接口和线程池来创建线程。

     1 package com.summer;
     2 
     3 import java.util.concurrent.Callable;
     4 import java.util.concurrent.FutureTask;
     5 
     6 public class ThreadC implements Callable {
     7 
     8     public Object call() throws Exception {
     9         System.out.println("start ThreadC!");
    10         return null;
    11     }
    12 
    13     public static void main(String[] args) {
    14         ThreadC threadC = new ThreadC();
    15         FutureTask futureTask = new FutureTask(threadC);
    16         Thread thread = new Thread(futureTask);
    17         thread.start();
    18     }
    19 }

     

     1 package com.summer;
     2 
     3 import java.util.concurrent.ExecutorService;
     4 import java.util.concurrent.Executors;
     5 
     6 public class ThreadD implements Runnable {
     7 
     8     public void run() {
     9         System.out.println("start ThreadD!");
    10     }
    11 
    12     public static void main(String[] args) {
    13         ExecutorService executorService = Executors.newSingleThreadExecutor();
    14         executorService.execute(new ThreadD());
    15     }
    16 }

    转载于:https://www.cnblogs.com/tanyang/p/11176103.html

    展开全文
  •    在看很多的关于java创建线程的博客中,发现的说创建新的线程有两种方式的说是三种方式。但是到底是一种是正确的呢 ? 两种创建方式: 一种是将类声明为Thread的子类,该类应重写Thread类的run方法,...

       在看很多的关于java创建新线程的博客中,发现有的说创建新的线程有两种方式,有的说是三种方式。但是到底是哪一种是正确的呢

    • 两种创建方式: 一种是将类声明为Thread的子类,该类应重写Thread类的run方法,另一种是实现Runnable接口,并实现run方法。
    • 三种创建方式: 在前面两种的方式+ 第三种:实现Callable< V > 接口,实现call方法。

       首先是从这两种结论可以看出:争论是在第三种实现Callable接口的方式 是不是java创建线程的方式!

    我还是先看脚踏实地看下这三种创建新的线程的方式:

    一. 将类声明为Thread的子类,并重写Thread类的run方法

     private static class ThreadSon extends Thread{
            @Override
            public void run(){
                System.out.println("thread子方法:" + Thread.currentThread().getName());
            }
        }
    
        public static void main(String[] args) {
            System.out.println("main方法:" + Thread.currentThread().getName());
            ThreadSon threadSon = new ThreadSon();
            threadSon.start();
        }
    

    执行结果:
    在这里插入图片描述

    二. 实现Runnable接口,重写fun方法

      private static class RunnableSon implements Runnable{
            @Override
            public void run() {
                System.out.println("runable子方法:" + Thread.currentThread().getName());
            }
        }
        
        public static void main(String[] args) {
            System.out.println("main方法:" + Thread.currentThread().getName());
            RunnableSon runnableSon = new RunnableSon();
            Thread t = new Thread(runnableSon);
            t.start();
        }
    

    执行结果:
    在这里插入图片描述

    三. 实现Callable接口,实现call方法

    private static class CallableSon  implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            System.out.println("子线程名称:" + Thread.currentThread().getName());
            return 123456;
        }
    }
    
    public static void main(String[] args) {
        System.out.println("主线程:" + Thread.currentThread().getName());
        CallableSon callableSon = new CallableSon();
        FutureTask<Integer> futureTask = new FutureTask<>(callableSon);
        Thread thread = new Thread(futureTask);
        thread.start();
    }
    

    执行结果:
    在这里插入图片描述
      从上面的运行结果上看,这三种方式都创建了新的线程,那么 “三种创建方式”的结论是正确的。然而事实真的是这样的吗?????

    四. 查看JDK文档

    在这里插入图片描述
      由上图可知,JDK官方文档上明确说明,有两种方式创建一个新的执行线程
      由下图可知,这两种方式,一种是继承Thread,重写run方法;另一种实现Runnable接口,实现run方法。
      由此说明,java创建新的线程的方式是两种!!!
    在这里插入图片描述

    五. 探究:为什么实现Callable接口的方式不被JDK官方承认这是一种新的创建线程的方式呢??

    private static class RunnableSon implements Runnable{
        @Override
        public void run() {
            System.out.println("runnable子方法:" + Thread.currentThread().getName());
        }
    }
    
    private static class CallableSon  implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            System.out.println("callable子方法:" + Thread.currentThread().getName());
            return 123456;
        }
    }
    public static void main(String[] args) {
        System.out.println("主线程:" + Thread.currentThread().getName());
        CallableSon callableSon = new CallableSon();
        FutureTask<Integer> futureTask = new FutureTask<>(callableSon);
        Thread thread = new Thread(futureTask);
        thread.start();
    
        RunnableSon runnableSon = new RunnableSon();
        Thread runThread = new Thread(runnableSon);
        runThread.start();
    }
    

      由上面的代码可知:Runnable和Callable都是通过new Thread(Runnable target)创建线程的,下面代码是Thread的含参构造,并初始化一个线程。

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

      下面是Callable的官方说明,Callable类似与Runnable,并由他们共同使用同一个初始化线程的方法。又因为Runnable Jdk1.0 就已经出现,而Callable Jdk1.5才出现,因此JDK官方也只是把他们俩算作一种创建线程的方式。
    在这里插入图片描述

    6. java 创建新的线程的方式是两种:一种是将类声明为Thread的子类,该类应重写Thread类的run方法,另一种是实现Runnable接口,并实现run方法。

      以上第五部分是本人查看源码的理解:如有偏差或错误,请不吝赐教!!!

    展开全文
  • 创建线程有两种方法,一种是继承Thread类创建线程类,而另外一种是实现Runnable接口创建线程类。那么这两种方法本质上什么区别呢?我们平时更倾向于种呢?下面我们就来讨论下着两种方法优势与劣势; 1).继承...
    创建线程有两种方法,一种是继承Thread类创建线程类,而另外一种是实现Runnable接口创建线程类。那么这两种方法本质上有什么区别呢?我们平时更倾向于哪种呢?下面我们就来讨论下着两种方法的优势与劣势;

    1).继承Thread类创建线程类  实现Runnable接口创建线程类

    public class Thread1 extends Thread{
    	@Override
    	public void run() {
    		while(true){
    			System.out.println("1" + Thread1.currentThread().getName());
    			try {
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			
    		}
    	}
    
    	public static void main(String[] args) {
    		Thread1 th = new Thread1();
    		th.start();
    
    	}
    }

    2).实现Runnable接口创建线程类

    public class Thread2 implements Runnable {
    	@Override
    	public void run() {
    		while (true) {
    			System.out.println("线程"+ Thread.currentThread().getName());
    			try {
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			
    
    		}
    
    	}
    
    	public static void main(String[] args) {
    		Thread2 th2 = new Thread2();
    		Thread th1 = new Thread(th2);
    		th1.start();
    		
    
    	}
    
    }

    那么这两种方法有什么区别呢?

    先来说说第一种吧:

    采用继承Thead类实现多线程:

    优势:编写简单,如果需要访问当前线程,只需使用this即可,无需使用Thead.currentThread()方法。

    劣势:因为这种线程类已经继承了Thead类,所以不能再继承其它类。

    第二种方法:

    采用实现Runable接口的多线程:

    优势:线程类只是实现了Runable接口,因此还可以继承其他类;

             在这种情况下,可以使多个线程共享一个target对象,所以非常适合多个线程用来处理同一份资源的情况,从而可以将cpu、代码和数据分开,形成清晰的模型,较好的体现面向对象思想。

    劣势:编程略有些复杂,如果要访问当前线程必须使用Thread.currentThread方法。











    展开全文
  • 文章目录创建线程的方式到底几种???使用Runnable接口创建线程继承Thread类创建线程创建线程的种方式更好?两种方式本质的对比1. Runnable:最终调用的是target(也就是Runnable接口的实现类)的run方法。2. ...

    创建线程的方式到底有几种???

    oracle官方说的是两种
    oracle的jdk文档

    使用Runnable接口创建线程

    实现Runnable接口,代码如下

    package createThreads;
    
    /**
     * @Auther: keith
     * @Date: 2020/5/7 20:14
     * @Description: 使用runnable接口创建线程
     */
    public class RunnableStyle implements Runnable {
    
        @Override
        public void run() {
            System.out.println("使用runnable创建线程");
        }
    
        public static void main(String[] args) {
    
            new Thread(new RunnableStyle()).start();
        }
    }
    

    继承Thread类创建线程

    继承Thread类,重写run方法,代码如下

    package createThreads;
    
    /**
     * @Auther: keith
     * @Date: 2020/5/7 20:16
     * @Description:
     */
    public class ThreadStyle extends Thread {
        @Override
        public void run() {
            System.out.println("使用thread创建线程");
        }
    
        public static void main(String[] args) {
            new ThreadStyle().start();
        }
    }
    

    创建线程的哪种方式更好?

    答案是:实现runnable接口。为什么呢?

    • 解耦,实现runnable接口,更专注于行为,只关心执行的任务(也就是run方法),与Thread类的启动、运行等等职责分开。
    • 线程池的对runnable接口的支持。
    • 扩展性更好,java不支持双继承,如果以后想继承其他类,就做不到了

    两种方式本质的对比

    1. Runnable:最终调用的是target(也就是Runnable接口的实现类)的run方法。

    在这里插入图片描述

    2. Thread:直接重写了Thread类的整个run方法


    同时使用Runnable接口以及Thread类实现线程,会发生什么?

    执行结果,最终调用的是Thread的run方法,如图
    在这里插入图片描述


    面向对象的角度思考

    Thread的run方法源码,如图
    在这里插入图片描述

    • 从图中可以看到,target表示的是Runnable的实现类。target!=null,就调用target的run方法,我们运行上方程序的时候,确实是传了target过来,但是,我们继承了Thread类重写了run方法,把runnable实现类的run方法覆盖了。所以,最终执行的方法是我们重写了Thread的run方法。

    总结

    • 实现线程只有两种方式,oracle官方这么说的
      1. 实现Runnable接口
      2. 继承Thread类
    • 其余创建线程的方式,如使用线程池、Callble等等,都只是表面现象,都是代码成面的封装,底层代码,最终的道理都是通过new Thread实现了线程,根本的无法逃脱Thread类和Runnable接口。
    展开全文
  • 线程的创建有两种方式,昨天学习过其中的一种:创建一个类,继承自Java里的Thread类,并重写run方法。最后再创建自定义线程的对象,并调用start方法,这样就启动一个线程了。那么Thread到底是个什么东西呢?一、...
  • 在开发中经常碰到这样一情况,就是使用一个已经继承了某一个类的子类创建线程,由于一个类不能同时有两个父类,所以不能用继承Thread类的方式,那么就只能采用实现Runnable接口的方式。现在大部分的多线程
  • 面试官:“你知道有哪几种创建线程的方式吗?”(此时你的心理活动:哈哈小意思这能难住我,忍住激动假装淡定道)你:“嗯,可以通过实现 Runnable 接口和继承 Thread 类来创建线程。”面试官:“除了这两种还有其他...
  • 1.、创建线程有哪两种方式? 两种方式: 继承Thread类 实现Runnable接口 2.如何通过继承Thread类来创建线程? 步骤: (1). 定义一个类,继承自Thread类,重写run()方法 (2). 创建该类实例,即创建一个线程 (3)....
  • 线程的创建有两种方式创建一个类,继承自Java里的Thread类,并重写run方法。 最后再创建自定义线程的对象,并调用start方法,这样就启动一个线程了。 那么Thread到底是个什么东西呢? 一、Thread类 在Java...
  • 线程同步自己及基本就用过Thread和Runnable这两种方式,还有其他很...创建线程有几种不同的方式?你喜欢一种?为什么? 而线程同步会用的方式就更少了,只会synchronized,其他方式如下: 关于线程同步(7种方式)...
  • 两种方式创建线程

    2017-04-10 18:01:03
    线程编程–两种方式创建多线程 ### 目的 创建线程,即拿到一个线程实例。这个线程实例必须具备开启、等待、唤醒等控制自身生命周期方法。 ### 创建线程 为什么Java要提供两种方法来创建线程呢?它们都哪些区别...
  • 创建线程的第一种方式: 创建一个类继承Thread 重写Thread中的run方法 (创建线程是为了执行任务任务代码必须存储位置,run方法就是任务代码的存储位置。) 创建子类对象,其实就是在创建线程 启动线程start...
  • 线程的创建有两种方式,昨天学习过其中的一种: 创建一个类,继承自Java里的Thread类,并重写run方法。最后再创建自定义线程的对象,并调用start方法,这样就启动一个线程了。那么Thread到底是个什么东西呢?一、...
  • 面试官:“你知道有哪几种创建线程的方式吗?”(此时你的心理活动:哈哈小意思这能难住我,忍住激动假装淡定道)你:“嗯,可以通过实现 Runnable 接口和继承 Thread 类来创建线程。”面试官:“除了这两种还有其他...
  • 对于这两种,也分别有两种启动线程的方式: 1)继承Thread类,implements Runnable接口 2)实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现返回结果的线程 ...
  • 面试官:“你知道有哪几种创建线程的方式吗?”(此时你的心理活动:哈哈小意思这能难住我,忍住激动假装淡定道)你:“嗯,可以通过实现 Runnable 接口和继承 Thread 类来创建线程。”面试官:“除了这两种还有其他...
  • 进程和线程 ...设想这样一种情况,将文件A从C盘移动到D盘,将文件B从E盘移动到F盘,现在有两种解决方案(单核CPU): 先移动A,完成后再移动B 同时移动A和B 那么,方式更快呢? 是方案一,因为同时移动
  • Java线程的创建

    2012-10-19 17:08:36
    实际上Runnable接口只有一个run方法,Thread也是实现了Runnable接口的,但是无论方式都必须借助Thread类,下面列举了创建线程的两种方式: -&gt;方式一:继承Thread类 public class ChildThread extends ...
  • 一.单词部分: ①process进程 ②current当前的③thread线程④runnable可获取的 ⑤interrupt中断⑥join加入⑦yield产生⑧synchronize同时...2.说明创建线程的方式有哪两种 ①继承thread类 ②实现Runnable接口 3....
  • 在JAVA中,有两种方法可以创建线程:一种是继承Thread类;另一种是实现Runnable接口。不管采用方式,都要用到JAVA类库中Thread类及相关方法。本实例将展示如何启动和结束线程 运行代码 import java.util.Date...
  • 使用多线程的好处,在于并行的执行多任务,彼此独立,可以提高执行效率。...实际上Thread类也是实现了Runnable接口的,关于这两种方式,官方给出了解释,选择实现Runnable接口创建线程,更有利于资源的共享,并...
  • 线程

    2020-02-02 22:13:04
    4.创建线程有哪种方式?5.说以下Runnable和Callable区别?6.线程都有哪些状态? 多线程 1.并行和并发有什么区别? 并行是指个或多个事件在同一时刻发生在不同实体上。 并发是指个或多个事件在同一时间间隔...
  • Java中创建一个线程的方式有哪有什么区别?1.集成Thread类 2.实现Runnable接口 3.实现Callable接口,它的call可以作为线程的执行体,Future接口作为作为call方法的返回值,只不过这种方法不经常使用。区别:主要...
  • 我们都知道,在java中要想实现多线程,有两种手段,一种是继续Thread类,另外一种是实现...创建线程有几种不同的方式?你喜欢一种?为什么?三种方式可以用来创建线程:(1)继承Thread类 (2)实现Runnab...
  • 定义一个 Thread 类有两种方式,一是在构造函数中直接调用一个要执行函数,二是覆盖创建的类中run()方法。不管种方法定义Thread类,都要通过内置start()方法来启动线程。Thread也内置了 is_alive()方法...
  • Java中启动线程有两种方式,继承Thread类以及实现接口Runnable,由于Java无法实现多重继承,故经常通过实现接口Runnable来创建线程。但是无论方式创建都可以通过start()和run( )方法来启动线程,下面就来介绍...
  • 创建线程的两种方式 不管是方式,都需要重写run方法,所有的业务处理都在这里 继承Thread 自定义线程类: public class MyThread extends Thread { //定义指定线程名称的构造方法 public MyThread(String ...
  • java多线程

    2018-06-10 20:59:45
    一、Java线程的概念在大多数操作系统中都可以...创建新线程必须编写一个线程类,用JAVA编写多线程代码有两种方式:第一种方式是直接继承java的线程类Thread;第二种是实现Runnable接口。无论方式均需要在程序...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 141
精华内容 56
关键字:

创建线程的方式有哪两种