精华内容
下载资源
问答
  • 创建线程的两种方式区别

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

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

     

     

     

     

    展开全文
  • 1.创建线程的两种方式区别 采用继承Thread类方式: (1)优点:编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this,即可获得当前线程。 (2)缺点:因为线程类已经继承了Thread...

    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创建线程的两种方式区别

    千次阅读 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");
            }
        }
    
    }
    
    

     

    展开全文
  • 创建线程1.继承Thread类定义类继承Thread, 重写run()方法, 将线程中要执行代码写在run()方法中创建该类对象, 调用start()方法就可以开启一条新线程, 新线程中自动指定run()方法public class ThreadDemo1 {public ...

    *** 一.创建线程

    1.继承Thread类

    定义类继承Thread, 重写run()方法, 将线程中要执行的代码写在run()方法中

    创建该类对象, 调用start()方法就可以开启一条新线程, 新线程中自动指定run()方法

    public class ThreadDemo1 {

    public static void main(String[] args) {

    // 3.创建线程对象

    MyThread mt = new MyThread();

    // 4.启动一条新线程, 新线程上自动执行run()方法

    mt.start();

    // 5.主线程循环打印

    for (int i = 0; i < 100; i++)

    System.out.println("A " + i);

    }

    }

    // 1.定义类继承Thread

    class MyThread extends Thread {

    // 2.重写run方法

    public void run() {

    for (int i = 0; i < 100; i++)

    System.out.println("B " + i);

    }

    }

    2.实现Runnable接口

    定义类实现Runnable接口, 重写run()方法, 将线程中要执行的代码写在run()方法中

    创建该类对象, 创建Thread类对象, 将Runnable对象传入Thread的构造函数中

    调用Thread对象的start()方法就可以开启一条新线程, 新线程中执行Runnable的run()方法

    public class ThreadDemo2 {

    public static void main(String[] args) {

    // 3.创建Runnable对象

    MyRunnable mr = new MyRunnable();

    // 4.创建Thread对象, 在构造函数中传入Runnable对象

    Thread t = new Thread(mr);

    // 5.调用start()开启新线程, 新线程自动执行Runnable的run()方法

    t.start();

    // 6.主线程循环打印

    for (int i = 0; i < 100; i++)

    System.out.println("A " + i);

    }

    }

    // 1.定义类, 实现Runnable接口

    class MyRunnable implements Runnable {

    // 2.实现run()方法

    public void run(){

    for (int i = 0; i < 100; i++)

    System.out.println("B " + i);

    }

    }

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

    千次阅读 2017-09-24 22:35:41
     (1)代码简单,直接通过Thread构造方法创建线程,且访问当前线程时,直接调用this.即可获得当前线程。  (2)因为已经继承Thread类,所以不能继承其他父类。  (3)若要个线程之间共享变量时,需要在声明...
  • **实现两种线程方式:**继承Thread,实现Runnable 查看源码的区别: 1.继承Thread类 由于子类重写Thread类了run(),当调用start()时,直接找子类的run()方程(注:由jvm自动调用) 2.实现Runnable类 构造函数...
  • 两种方式的区别: 继承Thread:线程代码存放Thread子类run方法中 实现Runable接口线程代码在接口子类的run方法 多线程的运行出现安全问题 问题的原因: 当多条语句在操作同一个线程共享数据时 一个线程对多条...
  • 使用QT创建线程两种方式,方式A使用moveToThread,方式B是直接继承QThread。差异主要在于方式A槽函数将会在新线程中运行,而方式B槽函数在旧线程中运行。 结论如下: PS:旧线程在这里指主线程,而新线程指...
  • 前言:看到很多博客上都写过多线程的实例以及这两种方式的区别,其中让我报有疑惑的一点是很多都说继承Thread而实现的多线程无法共享资源?我自己下来敲了敲,再结合一些资料做了如下总结 先创建了两个类,一个是...
  • 通过使用Callable创建线程的方式本文中不在讨论,可以参考:http://blog.csdn.net/dax1n/article/details/60322067 方式1: 实现Runnable接口创建线程 public class RunnableDemo implements Runnable { @...
  • 第一种方式: 通过实现Runnable接口创建线程package cn.qblank.thread; /** * 多线程案例1 * @author Administrator * */ public class ThreadTest1 implements Runnable{ private Thread t; //线程名 private...
  • 1、多线程安全问题分析2、多线程安全问题解决3、多线程安全问题细节  3.1、同步好处和弊端 3.2、同步前提 3.3、加入了同步安全依然存在 4、同步锁问题  4.1、同步是否可以加在run方法上 4.2、同步...
  • Java创建线程的两种方式 导航: 继承Thread类 实现Runnable方法 start()方法和run()方法区别 比较 实现接口的方式比继承类的方式更灵活, 也能减少程序之间的耦合度,面向接口编程也是设计模式6大原则的核心 ...
  • 创建线程两种方法: 需要从Java.lang.Thread类派生一个新线程类,重载它run()方法; 实现Runnalbe接口,重载Runnalbe接口中run()方法。 一、将类声明为Thread子类。该子类应重写Thread 类 run 方法...
  • 创建线程的种方式的区别 一.Java中关于应用程序和进程相关的概念 在Java中,一个应用程序对应着一个JVM实例(也有地方称为JVM进程),一般来说名字默认为java.exe或者javaw.exe(windows下可以通过任务管理器...
  • 创建线程两种方法,一种是继承Thread类创建线程类,而另外一种是实现Runnable接口创建线程类。那么这两种方法本质上有什么区别呢?我们平时更倾向于哪种呢?下面我们就来讨论下着两种方法优势与劣势; 1).继承...
  • 创建线程的两种方式

    2019-06-22 14:23:50
    先来了解一下与线程相关的概念,如程序,进程,以及他们之间的区别 1)、程序Program: 程序是一段静态的代码, 它是应用程序执行的蓝本。 2)、进程Process 进程是指一正在运行的程序, 有自己的地址空间。 3)、...
  • 创建一个新的线程有两种方式,第一种方式为通过继承Thread类,并实现Thread类中的run()方法。第二种创建线程的方式是通过实现Runnable接口来创建一个新的线程。 下面总结一下两种创建线程方式的区别: 从面向对象...
  • Java 提供了三种创建线程的方法: 通过实现 Runnable 接口; 通过继承 Thread 类; 通过 Callable 和 Future 创建线程。 这里只介绍两种第一种和第二种。   1.以创建Runnable接口实例的方式创建线程 public ...
  • 一:总结Java和JS的区别 同:都是一门语言。 不同:1)基于对象和面向对象:Java是一正在面向对象的语言,即使是开发简单的程序,也必须设计对象;JavaScript是一脚本语言,它可以用来制作与网络无关, 与用户...
  • 那么这两种实现多线程的方式在应用上有什么区别呢?   为了回答这个问题,我们可以通过编写一段代码来进行分析。我们用代码来模拟铁路售票系统,实现通过四个售票点发售某日某次列车的100张车票,一个售票点用一...
  • [转载请注明]...1.线程和进程的区别并行:是多个任务在同一时间同时执行,例如多核计算机同时计算的任务可以理解为并行 并发:从微观上看是多个任务抢占一个CPU从而执行自己的任务,轮
  • 1、扩展Thread类 2、实现Runnable接口 3.两者区别 采用继承Thread类方式: (1)... (2)缺点:因为线程类已经继承了Thread类,所以不能再继承其他父类。 采用实现Runnable接口方式: (1)优点: 线程类只是...
  • 进程个线程的区别 创建和启动线程

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 930
精华内容 372
关键字:

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