精华内容
下载资源
问答
  • 创建线程两种方式区别
    2020-07-03 16:05:40

    1.创建线程的两种方式及区别
    采用继承Thread类方式:
    (1)优点:编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this,即可获得当前线程。
    (2)缺点:因为线程类已经继承了Thread类,所以不能再继承其他的父类。
    采用实现Runnable接口方式:
    (1)优点:线程类只是实现了Runable接口,还可以继承其他的类。在这种方式下,可以多个线程共享同一个目标对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。
    (2)缺点:编程稍微复杂,如果需要访问当前线程,必须使用Thread.currentThread()方法。

    2…currentThread和this的区别
    ①Thread.currentThread表示当前代码段正在被哪个线程调用的相关信息。
    ②this表示的是当前对象,与Thread.currentThread有很大的区别。

    3.Thread使用start和run方法启动线程有什么区别
    1.start()方法来启动线程,真正实现了多线程运行,这时无需等待run方法体bai代码执行完毕而直接继续执行下面的代码:通过调用Thread类的start()方法来启动一个线程,
    这时此线程是处于就绪状态,并没有运行。然后通过此Thread类调用方法run()来完成其运行操作的,这里方法run()称为线程体,它包含了要执行的这个线程的内容,Run方
    法运行结束,此线程终止,而CPU再运行其它线程,
    2.run()方法当作普通方法的方式调用,程序还是要顺序执行,还是要等待run方法体执行完毕后才可继续执行下面的代码:
    而如果直接用Run方法,这只是调用一个方法而已,程序中依然只有主线程–这一个线程,其程序执行路径还是只有一条,这样就没有达到写线程的目的。

    更多相关内容
  • 主要介绍了Java创建线程两种方式,针对Java创建线程两种方式进行比较,感兴趣的小伙伴们可以参考一下
  • 主要为大家区分了java创建线程两种方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Java多线程实现方式两种,第一种是继承Thread类,第二种是实现Runnable接口,两种有很多差异,下面跟着本文一起学习吧
  • 在Java中创建线程方式两种,第一种是直接继承Thead类,另一种是实现Runable接口。那么这两种方式孰优孰劣呢?这就是本文需要探讨的内容范畴了,看官们请仔细向下看
  • java创建线程两种方式区别

    千次阅读 2018-07-24 18:35:47
    本文将介绍创建线程两种方式,示例代码在下面,复制粘贴即可 继承Thread类方式和实现Runnable接口方式 区别:由于在开发的过程中,很多的类都会用到继承的方式,如果采用继承的方式会让各个类之间的关系变得错综...

    本文将介绍创建线程的两种方式,示例代码在下面,复制粘贴即可

    继承Thread类方式和实现Runnable接口方式

    区别:由于在开发的过程中,很多的类都会用到继承的方式,如果采用继承的方式会让各个类之间的关系变得错综复杂

    使得程序的可读性变差,所以在开发当中一般都用实现接口的方式,而且实现接口的方式还可以共享资源,共享资源的

    示例将在以后列出。

    /*
     * 创建线程的第一种方式:继承方式
     * 1.定义线程类,继承Thread类
     * 2.覆盖其中的run方法,并且run方法得用public修饰,否则系统会报错
     * 3.在主函数中创建线程对象
     * 4.调用线程对象的start方法
     */
    class xiancheng extends Thread//第一步
    {
        public void run() //第二步
        {
            for(int x=0;x<60;x++) 
            {
                System.out.println("1");
            }
        }
    }
    
    public class Test1 {
    
        public static void main(String[] args) 
        {
            xiancheng t=new xiancheng();//第三步
            t.start();//第四步
            for(int x=0;x<500;x++) 
            {
                System.out.println("2");
            }
        }
    
    }
    /*
     * 创建线程的第二种方式:实现接口
     * 1.定义线程类并实现Runnable接口
     * 2.覆盖Runnable中的run方法
     * 3.创建Runnable的子类线程对象
     * 4.将创建的子类对象作为参数传给Thread类的构造函数中
     * 5.调用start方法开启线程
     */
    class xiancheng1 implements Runnable//第一步
    {
        public void run() //第二步
        {
            for(int x=0;x<60;x++) 
            {
                System.out.println("1");
            }
        }
    }
    public class Test2 {
    
        public static void main(String[] args) 
        {
            xiancheng1 t=new xiancheng1();//第三步
            Thread t1=new Thread(t);//第四步
            t1.start();//第五步
            for(int x=0;x<500;x++) //主线程
            {
                System.out.println("2");
            }
        }
    
    }
    
    

     

    展开全文
  • 主要介绍了Java多线程线程两种创建方式及比较代码示例,简单介绍了线程的概念,并行与并发等,然后通过实例代码向大家展示了线程创建,具有一定参考价值,需要的朋友可以了解下。
  • 主要介绍了Python 多线程,threading模块,创建线程两种方式,结合实例形式分析了Python线程的原理与创建线程的相关实现技巧,需要的朋友可以参考下
  • 创建线程两种方式

    2019-06-22 14:23:50
    先来了解一下与线程相关的概念,如程序,进程,以及他们之间的区别 1)、程序Program: 程序是一段静态的代码, 它是应用程序执行的蓝本。 2)、进程Process 进程是指一正在运行的程序, 有自己的地址空间。 3)、...

    先来了解一下与线程相关的概念,如程序,进程,以及他们之间的区别

    1)、程序Program:

    程序是一段静态的代码, 它是应用程序执行的蓝本。

    2)、进程Process

    进程是指一种正在运行的程序, 有自己的地址空间。

    3)、线程Thread

    进程内部的一个执行单元, 它是程序中一个单一的顺序控制流程。线程又被称为轻量级进程(lightweight process)。如果在一个进程中同时运行了多个线程, 用来完成不同的工作, 则称之为多线程。
    线程的特点:

    • 轻量级进程
    • 独立调度的基本单位
    • 可并发执行
    • 共享进程资源

    4)、进程与线程的区别

    区别进程线程
    根本区别作为资源分配的最小单位作为资源调度和执行的最小单位
    开 销每个进程都有独立的代码和数据空间(进程上下文), 进程间的切换会有较大的开销。线程可以看成时轻量级的进程, 同一类线程共享代码和数据空间, 每个线程有独立的运行栈和程序计数器(PC), 线程切换的开销小。
    所处环境在操作系统中能同时运行多个任务(程序)在同一应用程序中有多个顺序流同时执行
    分配内存系统在运行的时候会为每个进程分配不同的内存区域除了CPU之外, 不会为线程分配内存(线程所使用的资源是它所属的进程的资源) , 线程组只能共享资源
    包含关系没有线程的进程是可以被看作单线程的, 如果一个进程内拥有多个线程, 则执行过程不是一条线的, 而是多条线(线程) 共同完成的。线程是进程的一部分, 所以线程有的时候被称为是轻权进程或者轻量级进程。

    5)、线程的生命周期

    (json插队方法,属于对象 t1.join()表示必须等到t1线程执行完,才执行其他线程,t1执行的时候,其他线程都是属于阻塞状态)

    1、新生状态 (一旦开启了新生状态,线程就有了自己的工作空间)

    2、就绪状态(等待cpu调度,调用start方法)yield让出cpu的调度直接从运行状态转换到就绪状态、时间片用完由运行变就绪状态、jvm算法切换

    3、运行状态(cpu调度到改线程)

    4、阻塞状态(如,执行sleep方法,wait,或同步代码锁、join方法)

    5、死亡状态(线程正常执行完毕,或者调用stop方法【不推荐,线程不安全】,通过标识符 使用terminate方法)


    1)、创建线程的第一种方式:

    继承Thread类,重写run方法

    public class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("当前线程的名字--->"+Thread.currentThread().getName());
        }
    
        public static void main(String[] args) {
    		//创建4个线程
            MyThread t1 = new MyThread();
            MyThread t2 = new MyThread();
            MyThread t3 = new MyThread();
            MyThread t4 = new MyThread();
    	//开启线程
            t1.start();
            t2.start();
            t3.start();
            t4.start();
    
            System.out.println("当前线程的名字--->"+Thread.currentThread().getName());
        }
    }
    

    输出结果:

    当前线程的名字--->main
    当前线程的名字--->Thread-0
    当前线程的名字--->Thread-1
    当前线程的名字--->Thread-3
    当前线程的名字--->Thread-2
    

    这里线程的执行顺序并不是按照我们 执行start()的顺序,因为start()方法,并不是代表立即去执行线程,只不过是告诉cpu我可以被调度,至于它先执行哪个线程,要靠cpu去决定。(但是我们可以设置一个优先级,优先级高的显被执行的概率大,但是不是绝对的)

    2)、创建线程的第二种方式:

    实现Runnable接口。重写run方法

    public class MyRanableThread implements Runnable
    {
        @Override
        public void run() {
            System.out.println("当前线程的名字--->"+Thread.currentThread().getName());
        }
    
        public static void main(String[] args) {
    
            Thread t1 = new Thread(new MyRanableThread());
            t1.start();
            new Thread(new MyRanableThread()).start();
            new Thread(new MyRanableThread()).start();
            new Thread(new MyRanableThread()).start();
        }
    }
    

    执行结果:

    当前线程的名字--->Thread-2
    当前线程的名字--->Thread-0
    当前线程的名字--->Thread-1
    当前线程的名字--->Thread-3
    

    通过Thread的构造方法传入Runnable接口的实现类,然后执行start()方法,开启线程,相对于第一种方式,这里的Thread其实就是个静态代理对象。
    那么两种的方式有什么区别呢
    执行了start()方法之后,当线程被cpu调度之后,就会执行run()方法,进入Thread这个类,看一下run()方法的源码(部分):

    class Thread implements Runnable //thread类其实也是实现了Ruanable接口
    	
    	   /* What will be run. */
        private Runnable target;
        
        @Override
        public void run() {
            if (target != null) {
                target.run();
            }
        }
    
    

    原来当我们使用第一种方法 继承Thread类,重写run方法,在调用run方法的时候,必然就会调用子类重写的run方法,然后执行。但当我用第二种方法,也就是Thread构造传入Runnable接口的实现类之后,当我们要执行run方法,会先判断target是否为空,然后执行target.run(),也就是我们实现Runnable时候所重写的run方法。

    展开全文
  • 创建线程两种方式区别

    千次阅读 2017-02-01 12:49:29
    其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象。每个Thread对象描述了一个单独的线程。要产生一个线程,有两种方法: ◆需要从Java.lang.Thread类派生一个新的线程类...

    Java提供了线程类Thread来创建多线程的程序。其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象。每个Thread对象描述了一个单独的线程。要产生一个线程,有两种方法:

    ◆需要从Java.lang.Thread类派生一个新的线程类,重载它的run()方法。 
    ◆实现Runnalbe接口,重载Runnalbe接口中的run()方法。

    下面就从几个例子来具体列出两种方式的区别

    第一种方式:继承Thread类

    实现步骤:

    1.自定义类继承Thread 

    2.覆盖Thread中的run()方法

    3.创建该类的对象,调用start()方法,开启线程并调用run方法

    简单实例:

    class MyThread extends Thread{  
        public void run(){  
            for (int i = 0; i < 100; i++){  
                System.out.println("MyThread.run()..."+i);  
            }   /*单条线程运行一百次*/
        }  
    }  
    public class test1{  
        public static void main (String[] args){  
            MyThread a = new MyThread();  
            a.start();  
            for (int j = 0; j < 100; j++){  
                System.out.println("test1.main()----"+j);  
            }  
        }  
    }  
    
    第二种方式:实现Runnable接口

    实现步骤:

    1.定义一个实现Runnable接口的类

    2.覆盖run方法

    3.创建该类对象,并以该类对象为参数创建Thread类的对象,从而创建了一个线程

    4.调用start方法,开启线程并调用run方法。

    简单实例:

    class MyThread implements Runnable{  
        public void run (){  
            for (int i = 0; i < 50; i++){  
                System.out.println("MyThread.run()..."+i);  
            }                       /*每条线程运行50次,共200次*/
        }  
    }  
    public class test1{  
        public static void main (String[] args){  
            MyThread a = new MyThread();  
            Thread a1 = new Thread(a);  
            Thread a2 = new Thread(a);  
            Thread a3 = new Thread(a);  
            Thread a4 = new Thread(a);  
      
            a1.start();  
            a2.start();  
            a3.start();  
            a4.start();  
        }  
    }

    从上面两个例子看,除了多一个步骤外两种方式区别并不大 那么为什么通常都使用第二种方式呢 我们来看第三个例子

    public class test1{
        public static void main(String [] args){
            MyThread m=new MyThread();
            Thread t1=new Thread(m,"Thread 1");
            Thread t2=new Thread(m,"Thread 2");
            Thread t3=new Thread(m,"Thread 3");
            t1.start();         /*共运行一百次,  三条线程哪条抢到资源就运行哪条  */
            t2.start();
            t3.start();
        }
    }
    class MyThread implements Runnable{
        private int i=0;
        public void run(){
            while(i<100){
                i++;
            	System.out.println(i+"  MyThread.run "+Thread.currentThread().getName());
            }
        }
    }

    从这个例子我们可以看出,如果现实问题中要求必须创建多个线程来执行同一任务,而且这多个线程之间还将共享同一个资源,那么就可以使用实现Runnable接口的方式来创建多线程程序。而这一功能通过扩展Thread类是无法实现的。

    实现Runnable接口相对于扩展Thread类来说,具有无可比拟的优势。这种方式不仅有利于程序的健壮性,使代码能够被多个线程共享,而且代码和数据资源相对独立,从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来,线程、代码和数据资源三者有效分离,很好地体现了面向对象程序设计的思想。因此,几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。

    总结:

    采用继承Thread类方式:
    (1)优点:编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this,即可获得当前线程。
    (2)缺点:因为线程类已经继承了Thread类,所以不能再继承其他的父类。
    采用实现Runnable接口方式:
    (1)优点:线程类只是实现了Runable接口,还可以继承其他的类。在这种方式下,可以多个线程共享同一个目标对象,所以非常适合多个相 同线程来处理同一份资源的情况,从而可以将CPU代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。
    (2)缺点:编程稍微复杂,如果需要访问当前线程,必须使用Thread.currentThread()方法。

    展开全文
  • 下面总结一下两种创建线程方式区别: 从面向对象编程的角度来看:通过继承Thread类创建线程使用的是基于继承的技术,而第二种方式是当然就是给予组合的技术来实现的。由于组合相对于继承来说,类与类之间的耦合性...
  • 创建线程种方式

    千次阅读 2019-04-12 12:07:59
    创建线程的几种方式方式1:通过继承Thread类创建线程 步骤:1.定义Thread类的子类,并重写该类的run方法,该方法的方法体就是线程需要执行的任务,因此run()方法也被称为线程执行体 2.创建Thread子类的实例,...
  • 多线程之创建线程两种方式

    万次阅读 多人点赞 2018-05-29 00:33:56
    彩蛋: ...言归正传,今晚准备详细记录一下线程创建两种方式以及这两种方式的优缺点及适应的情况等等。 多进程:。。。 多线程:在一个应用程序中,有多个顺序流同时执行。(线程:顺序执行的代...
  • 创建线程两种方式以及区别

    千次阅读 2017-09-24 22:35:41
     (1)代码简单,直接通过Thread的构造方法创建线程,且访问当前线程时,直接调用this.即可获得当前线程。  (2)因为已经继承Thread类,所以不能继承其他父类。  (3)若要个线程之间共享变量时,需要在声明...
  • 要说Java中的线程使用,有两种方式,一个是继承Thread类,直接调用子类的run()方法,另一个是产生一个实现Runnable接口的类,做为Thread类的直接创建入参,启动均调用start方法,前者会直接调用子类的run()实现逻辑...
  • 主要介绍了Java创建和启动线程两种方式,结合实例形式分析了java多线程创建、使用相关操作技巧与注意事项,需要的朋友可以参考下
  • java创建线程的四种方式及其区别

    千次阅读 2019-04-26 18:35:25
    继承Thread类创建线程 实现Runnable接口创建线程 使用Callable和Future创建线程 使用线程池创建(使用java.util.concurrent.Executor接口) 下面分别介绍这四创建多线程的方式 1. ----------------------继承...
  • 创建并使用线程

    2020-12-30 18:40:26
     两种方式创建新的线程:  实现 Runnable 接口,Runnable 接口定义了一个方法:run。run 方法中的代码,将在创建线程中执行。实现了 Runnable 接口的对象,作为 Thread 构造方法的参数。  ...
  • 方法一:继承Thread类创建线程* (1)d定义Thread类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务,run()方法也称为线程执行体。 (2)创建Thread子类的实例,也就是创建了线程对象 (3)...
  • 线程的三种创建方式以及区别

    千次阅读 2021-03-07 18:10:39
    这里写目录标题一:创建线程的三种方式1.继承类Thread的方式2.继承Runnable接口方式3.使用Callable接口创建线程4.这三种创建线程区别 一:创建线程的三种方式 1.继承类Thread的方式 注意:这种创建线程方式不能再...
  • Qt5中两种线程操作的方法 1. 通过创建QTread子实现run()函数来实现 QThread::run()是线程的入口 相当于 main函数一样 创建线程通过调用start()来执行run(); run() 是一个虚函数 通过子类实现方法 通过moveToThread...
  • Android创建线程两种方式及比较

    万次阅读 2018-06-05 21:06:43
    一、Android创建线程方式通常为以下两种:  Java提供了线程类Thread来创建多线程的程序。其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象。每个Thread对象描述了一个...
  • Java中创建线程的4种方式以及区别

    千次阅读 2018-08-01 17:36:58
    Java可以用三种方式创建线程,如下所示: 1)继承Thread类创建线程 2)实现Runnable接口创建线程 3)使用Callable和Future创建线程 4)匿名类创建线程(new) 下面让我们分别来看看这三创建...
  • 简述两种JAVA多线程创建方式

    千次阅读 2020-07-27 01:59:35
    三、创建多线程的两种方式 第一种, 通过继承Thread类创建线程类 1、定义一个类继承Thread类,并重写Thread类的run()方法,run()方法的方法体就是线程要完成的任务,因此把run()称为线程的执行体; 2、创建该类的实
  • java中创建线程的4种方式

    千次阅读 2019-04-25 16:00:23
    这种问题在面试中经常被问到,你可能心里马上反映出两种方式(实现Runnable、继承Thread),当你把这两种叙述给面试官听后,面试官会觉得你该掌握的知识已经有了,但是仅仅而已。如果你还说了callable与future、...
  • 线程的4种创建方式区别

    千次阅读 2020-08-04 16:32:51
    从 1、继承Thread类 2、实现Runnable接口 3、实现Callable接口 4、创建线程池
  • [转载请注明]...1.线程和进程的区别并行:是多个任务在同一时间同时执行,例如多核计算机同时计算的任务可以理解为并行 并发:从微观上看是多个任务抢占一个CPU从而执行自己的任务,轮
  • java 创建线程的三种方式、创建线程池的四种方式

    万次阅读 多人点赞 2019-02-23 21:01:44
    java创建线程的三种方式: 继承Thread类创建线程类 实现Runnable接口 通过Callable和Future创建线程 java创建线程池的四种方式: newCachedThreadPool 创建一个可缓存的线程池,如果线程池长度超过处理...
  • java创建线程的四种方式

    千次阅读 2022-03-14 11:52:41
    4.使用线程池创建线程 1.直接初始化Thead类,实现Runnable接口 查看Thread类源码可以发现,有下面这么一个构造参数,target是线程启动的时候要调用的方法(Runnable接口中有个run方法),如果为空,那这个类的运行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 908,252
精华内容 363,300
关键字:

创建线程的两种方式的区别