精华内容
下载资源
问答
  • 创建线程的两种方法的区别
    千次阅读
    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要提供两种方法创建线程呢?它们都有哪些区别?相比而言,哪一种方法更好呢?  在Java中,类仅支持单继承,也是说,当定义一个新的类的时候,它只能扩展一个外部类.这样,如果创建自定义线程
  • 经过总结,Python创建线程主要有如下两种方法: 函数 类 接下来,我们就来揭开多线程的神秘面纱。 . 学会使用函数创建线程 在Python3中,Python提供了一个内置模块 threading.Thread,可以很方便地让我们创建...
  • Java创建线程两种方法 目录 继承Thread类的方式 实现Runnable接口的方式 自定义线程 继承Thread类 在Java中要实现线程最简单的方式就是扩展Thread类重写其中的run方法方法原型如下 Thread类中的run方法本身并不...
  • PAGE / NUMPAGES 在Java中创建线程两种方法使用Thread类和使用Runnable接口在使用Runnable接口时需要建立一个Thread实例因此无论是通过Thread类还是Runnable接口建立线程都必须建立Thread类或它的子类的实例Thread...
  • Java创建线程两种方法

    千次阅读 2021-02-27 15:34:23
    实现Runnable接口创建线程的最简单的方法就是创建一个实现Runnable 接口的类。Runnable抽象了一个执行代码单元。你可以通过实现Runnable接口的方法创建每一个对象的线程。为实现Runnable 接口,一个类仅需...

    大多数情况,通过实例化一个Thread对象来创建一个线程。Java定义了两种方式:

    实现Runnable 接口;

    可以继承Thread类。

    下面的两小节依次介绍了每一种方式。

    实现Runnable接口

    创建线程的最简单的方法就是创建一个实现Runnable 接口的类。Runnable抽象了一个执行代码单元。你可以通过实现Runnable接口的方法创建每一个对象的线程。为实现Runnable 接口,一个类仅需实现一个run()的简单方法,该方法声明如下:

    public void run( )

    在run()中可以定义代码来构建新的线程。理解下面内容是至关重要的:run()方法能够像主线程那样调用其他方法,引用其他类,声明变量。仅有的不同是run()在程序中确立另一个并发的线程执行入口。当run()返回时,该线程结束。

    在你已经创建了实现Runnable接口的类以后,你要在类内部实例化一个Thread类的对象。Thread 类定义了好几种构造函数。我们会用到的如下:

    Thread(Runnable threadOb, String threadName)

    该构造函数中,threadOb是一个实现Runnable接口类的实例。这定义了线程执行的起点。新线程的名称由threadName定义。

    建立新的线程后,它并不运行直到调用了它的start()方法,该方法在Thread 类中定义。本质上,start() 执行的是一个对run()的调用。 Start()方法声明如下:

    void start( )

    下面的例子是创建一个新的线程并启动它运行:

    1 //Create a second thread.

    2 class NewThread implementsRunnable {3 Thread t;4 NewThread() {5 //Create a new, second thread

    6 t = new Thread(this, "Demo Thread");7 System.out.println("Child thread: " +t);8 t.start(); //Start the thread

    9 }10

    11 //This is the entry point for the second thread.

    12 public voidrun() {13 try{14 for(int i = 5; i > 0; i--) {15 System.out.println("Child Thread: " +i);16 Thread.sleep(500);17 }18 } catch(InterruptedException e) {19 System.out.println("Child interrupted.");20 }21 System.out.println("Exiting child thread.");22 }23 }24

    25 classThreadDemo {26 public static voidmain(String args[]) {27 new NewThread(); //create a new thread

    28 try{29 for(int i = 5; i > 0; i--) {30 System.out.println("Main Thread: " +i);31 Thread.sleep(1000);32 }33 } catch(InterruptedException e) {34 System.out.println("Main thread interrupted.");35 }36 System.out.println("Main thread exiting.");37 }38 }

    在NewThread 构造函数中,新的Thread对象由下面的语句创建::

    t = new Thread(this, "Demo Thread");

    通过前面的语句this 表明在this对象中你想要新的线程调用run()方法。然后,start() 被调用,以run()方法为开始启动了线程的执行。这使子线程for 循环开始执行。调用start()之后,NewThread 的构造函数返回到main()。当主线程被恢复,它到达for 循环。两个线程继续运行,共享CPU,直到它们的循环结束。该程序的输出如下:

    Child thread: Thread[Demo Thread,5,main]

    Main Thread: 5

    Child Thread: 5

    Child Thread: 4

    Main Thread: 4

    Child Thread: 3

    Child Thread: 2

    Main Thread: 3

    Child Thread: 1

    Exiting child thread.

    Main Thread: 2

    Main Thread: 1

    Main thread exiting.

    如前面提到的,在多线程程序中,通常主线程必须是结束运行的最后一个线程。实际上,一些老的JVM,如果主线程先于子线程结束,Java的运行时间系统就可能“挂起”。前述程序保证了主线程最后结束,因为主线程沉睡周期1000毫秒,而子线程仅为500毫秒。这就使子线程在主线程结束之前先结束。简而言之,你将看到等待线程结束的更好途径。

    扩展Thread

    创建线程的另一个途径是创建一个新类来扩展Thread类,然后创建该类的实例。当一个类继承Thread时,它必须重载run()方法,这个run()方法是新线程的入口。它也必须调用start()方法去启动新线程执行。下面用扩展thread类重写前面的程序:

    1 //Create a second thread by extending Thread

    2 class NewThread extendsThread {3 NewThread() {4 //Create a new, second thread

    5 super("Demo Thread");6 System.out.println("Child thread: " + this);7 start(); //Start the thread

    8 }9

    10 //This is the entry point for the second thread.

    11 public voidrun() {12 try{13 for(int i = 5; i > 0; i--) {14 System.out.println("Child Thread: " +i);15 Thread.sleep(500);16 }17 } catch(InterruptedException e) {18 System.out.println("Child interrupted.");19 }20 System.out.println("Exiting child thread.");21 }22 }23

    24 classExtendThread {25 public static voidmain(String args[]) {26 new NewThread(); //create a new thread

    27 try{28 for(int i = 5; i > 0; i--) {29 System.out.println("Main Thread: " +i);30 Thread.sleep(1000);31 }32 } catch(InterruptedException e) {33 System.out.println("Main thread interrupted.");34 }35 System.out.println("Main thread exiting.");36 }37 }

    该程序生成和前述版本相同的输出。子线程是由实例化NewThread对象生成的,该对象从Thread类派生。注意NewThread 中super()的调用。该方法调用了下列形式的Thread构造函数:

    public Thread(String threadName)

    这里,threadName指定线程名称。

    选择合适方法

    到这里,你一定会奇怪为什么Java有两种创建子线程的方法,哪一种更好呢。所有的问题都归于一点。Thread类定义了多种方法可以被派生类重载。对于所有的方法,惟一的必须被重载的是run()方法。这当然是实现Runnable接口所需的同样的方法。很多Java程序员认为类仅在它们被加强或修改时应该被扩展。因此,如果你不重载Thread的其他方法时,最好只实现Runnable 接口。这当然由你决定。然而,在本章的其他部分,我们应用实现runnable接口的类来创建线程。

    转自微学苑(http://www.weixueyuan.net/view/6027.html)

    展开全文
  • 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");
            }
        }
    
    }
    
    

     

    展开全文
  • 创建并使用线程

    2020-12-30 18:40:26
     两种方式,创建新的线程:  实现 Runnable 接口,Runnable 接口定义了一个方法:run。run 方法中的代码,将在创建线程中执行。实现了 Runnable 接口的对象,作为 Thread 构造方法的参数。  ...
  • 创建线程两种方式

    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方法。

    展开全文
  • 详细的介绍了java中创建两种线程方法区别
  • 线程创建两种方式,昨天学习过其中的一种: 创建一个类,继承自Java里的Thread类,并重写run方法。 最后再创建自定义线程的对象,并调用start方法,这样就启动一个线程了。 那么Thread到底是个什么东西呢? ...
  • QT线程创建两种方法

    千次阅读 2022-03-06 21:59:11
    QT提供的第二种线程创建方式弥补了第一方式的缺点,用起来更加灵活,步骤如下: 1.创建一个新的类,让这个类从QObject派生 class ThreadWork:public QObject { … } 2.在这个类中添加一个公共的成员函数,函数体...
  • c++中两种创建线程方法

    千次阅读 2019-02-09 18:25:52
    方法一:正常创建线程函数,如果要在线程函数中调用对话框类中的变量,则需要对话框的类指针传递给线程函数:在类外定义CWnd *m_Cwnd;在类中赋值 m_Cwnd = this;然后在线程函数中使用m_Cwnd ; 代码如下: ...
  • 线程两种常用创建方式

    千次阅读 2019-11-22 11:05:52
    方法一:继承Thread类创建线程* (1)d定义Thread类的子类,并重写该类的run()方法,该方法方法体就是线程需要完成的任务,run()方法也称为线程执行体。 (2)创建Thread子类的实例,也就是创建了线程对象 (3)...
  • Qt多线程两种创建方法以及快速停止线程方法

    千次阅读 多人点赞 2022-04-14 16:12:24
    Qt多线程两种创建方法(继承QThread,moveToThread方法)以及快速停止线程方法
  • 多线程之创建线程两种方式

    万次阅读 多人点赞 2018-05-29 00:33:56
    彩蛋: ...言归正传,今晚准备详细记录一下线程创建两种方式以及这两种方式的优缺点及适应的情况等等。 多进程:。。。 多线程:在一个应用程序中,有多个顺序流同时执行。(线程:顺序执行的代...
  • Linux下预创建线程并发网络服务器的两种实现方法.pdf
  • 创建线程程序的第一方式:创建Thread类的子类 。 java.lang.Thread类:是描述线程的类,我们想要实现多线程程序,就必须继承Thread类。 实现步骤: 创建一个Thread类的子类。 在Thread类的子类中重写Thread...
  • 线程创建的三方式及区别

    千次阅读 2021-07-13 11:12:30
    创建Thread子类的实例,即创建线程对象。 调用线程对象的start()方法来启动线程。 package Thread; /* 1.继承Thread类 2.重写run()方法 3.调用start()方法开启线程 */ public class TestThread extends ...
  • 创建线程方式

    千次阅读 2021-05-30 16:00:37
    第一方式:Thread class 继承Thread...//创建线程方法一,继承Thread类,重写run()方法,调用start开启线程 public class TestThread1 extends Thread{ public void run(){ for (int i = 0; i < 20; i++) { S
  • 【并发编程】创建并运行线程的5种方法的对比

    千次阅读 多人点赞 2022-03-17 08:08:47
    并发编程就是基础中的基础,我的CSDN专栏《并发编程》中已经写了20篇关于java并发编程方面的文章,但我感觉这还仅仅是其中的冰山一角。这个专栏我还会继续写下去,这一篇的内容相对基础:《创建线程的四方式》。
  • 线程创建两种方式,昨天学习过其中的一种:创建一个类,继承自Java里的Thread类,并重写run方法。最后再创建自定义线程的对象,并调用start方法,这样就启动一个线程了。那么Thread到底是个什么东西呢?一、...
  • 创建线程两种方式区别

    千次阅读 2019-02-24 12:54:54
    Java提供了线程类Thread来创建多...要产生一个线程,有两种方法: ◆需要从Java.lang.Thread类派生一个新的线程类,重载它的run()方法。  ◆实现Runnalbe接口,重载Runnalbe接口中的run()方法。 下面就从几个例...
  • 创建线程的几方式

    千次阅读 2022-03-22 15:26:58
    创建线程的几方式: 方式1:通过继承Thread类创建线程 步骤:1.定义Thread类的子类,并重写该类的run方法,该方法方法体就是线程需要执行的任务,因此run()方法也被称为线程执行体 2.创建Thread子类的实例,也...
  • 线程创建的四方式

    千次阅读 2021-05-16 22:43:19
    java中创建线程的四种方法以及区别 Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例。Java可以用四方式来创建线程,如下所示: 1)继承Thread类创建线程 2)实现Runnable接口创建线程 ...
  • java创建线程的三方式

    千次阅读 2022-06-05 22:10:43
    线程创建的三方式及其对比

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 937,200
精华内容 374,880
热门标签
关键字:

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