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

    2017-06-05 19:51:30
    演示创建线程的两种方法
    /**
    *@程序名:SetThread_1.java
    *@编程人:***
    *@程序功能:演示继承Thread类创建线程的方法
    *@编程日期:2017-05-31
    */
    
    public class SetThread_1 {
    	public static void main(String [] args){
    		
    		//通过创建继承Thread类的Runner类的对象创建线程
    		Runner r = new Runner();
    		
    		//启动线程
    		r.start();
    		//如果使用r.run()仅相当于方法的调用
    	}
    }
    
    //定义一个继承Thread类的Runner类
    class Runner extends Thread {
    	
    	//定义线程所拥有的方法
    	public void run (){
    		for(int i=0;i<100;i++){
    			System.out.println("现在是线程在执行:"+i);
    		}
    	}
    }


    /**
    *@程序名:SetThread_2.java
    *@编程人:***
    *@程序功能:演示实现Runnable接口创建线程的方法
    *@编程日期:2017-05-31
    */
    
    public class SetThread_2 {
    	public static void main(String [] args){
    
    		//创建MyThread的对象,并用这个对象作为Thread类构造器的参数
    		MyThread r = new MyThread();
    		Thread t = new Thread(r);
    		
    		t.start();
    	}
    }
    
    //定义一个实现Runnable接口的类
    class MyThread implements Runnable {
    	public void run (){
    		for(int i=0;i<100;i++){
    			System.out.println("现在是线程在执行:"+i);
    		}
    	}
    }


    展开全文
  • java创建线程的两种方法区别发布于 2020-7-15|复制链接摘记: 在Java中创建一个线程有两种方法:继承Thread类和实现Runnable接口。下面通过两个例子来分析两者的区别:1)继承Thread类```javapublic class TestThread ...

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

    发布于 2020-7-15|

    复制链接

    摘记: 在Java中创建一个线程有两种方法:继承Thread类和实现Runnable接口。下面通过两个例子来分析两者的区别:1)继承Thread类

    ```java

    public class TestThread extends Thread {

    int count = 3;

    pu ..

    在Java中创建一个线程有两种方法:继承Thread类和实现Runnable接口。下面通过两个例子来分析两者的区别:1)继承Thread类

    ```java

    public class TestThread extends Thread {

    int count = 3;

    public TestThread(String ThreadName) {

    super(ThreadName);

    }

    @Override

    public void run() {

    for (int i = 0; i 0) {

    System.out.println(Thread.currentThread().getName() + "--->" + count);

    count--;

    }

    }

    public static void main(String[] args) {

    //new三个线程并启动

    new TestThread("线程一").start();

    new TestThread("线程二").start();

    new TestThread("线程三").start();

    }

    }

    ```

    输出结果:

    线程一--->3

    线程一--->2

    线程一--->1

    线程二--->3

    线程二--->2

    线程二--->1

    线程三--->3

    线程三--->2

    线程三--->1

    2)实现Runnable接口同样跟继承Thread的代码:

    ```java

    public class TestThread implements Runnable {

    int count = 3;

    public TestThread() {

    }

    @Override

    public void run() {

    for (int i = 0; i 0) {

    System.out.println(Thread.currentThread().getName() + "--->" + count);

    count--;

    }

    }

    public static void main(String[] args) {

    TestThread tr = new TestThread();

    //new三个线程并启动同一个Runnable

    new Thread(tr, "线程一").start();

    new Thread(tr, "线程二").start();

    new Thread(tr, "线程三").start();

    }

    }

    ```

    输出结果:线程一--->3

    线程一--->2

    线程一--->1 可以发现两种新建线程的方式最后的输出结果不一样,是因为在继承Thread类中,同时创建了三个线程,每个线程都执行一个任务,相当于三个线程分别各自进行三次循环打印log;而在第二种实现Runnable接口中是创建三个Thread共同去执行tr这个Runnable,相当于三个Thread共同去执行这一个循环,使得最后count只循环了一次,剩余线程二和线程三都因为使用同一个count导致未能打印出来。结论:1)两种创建线程的实现方式不一样,一个通过继承一个通过实现接口,在Java中如果已经继承了其他的父类,那么只能实现接口来创建线程。2)通过上面的例子可以看到继承Thread,每个线程都独立拥有一个对象,而实现Runnable对象,多个线程共享一个Runnable实例。

    展开全文
  • 主要为大家区分了java创建线程的两种方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Java提供了线程类Thread来创建多...要产生一个线程,有两种方法:◆需要从Java.lang.Thread类派生一个新的线程类,重载它run()方法;◆实现Runnalbe接口,重载Runnalbe接口中run()方法。为什么Java要提供两种方...

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

    ◆需要从Java.lang.Thread类派生一个新的线程类,重载它的run()方法;

    ◆实现Runnalbe接口,重载Runnalbe接口中的run()方法。

    为什么Java要提供两种方法来创建线程呢?它们都有哪些区别?相比而言,哪一种方法更好呢?

    在Java中,类仅支持单继承,也就是说,当定义一个新的类的时候,它只能扩展一个外部类.这样,如果创建自定义线程类的时候是通过扩展 Thread类的方法来实现的,那么这个自定义类就不能再去扩展其他的类,也就无法实现更加复杂的功能。因此,如果自定义类必须扩展其他的类,那么就可以使用实现Runnable接口的方法来定义该类为线程类,这样就可以避免Java单继承所带来的局限性。

    还有一点最重要的就是使用实现Runnable接口的方式创建的线程可以处理同一资源,从而实现资源的共享.

    1、通过扩展Thread类来创建多线程

    假设一个影院有三个售票口,分别用于向儿童、成人和老人售票。影院为每个窗口放有100张电影票,分别是儿童票、成人票和老人票。三个窗口需要同时卖票,而现在只有一个售票员,这个售票员就相当于一个CPU,三个窗口就相当于三个线程。通过程序来看一看是如何创建这三个线程的。

    1 public classMutliThreadDemo {2 public static voidmain(String[] args) {3 MutliThread m1=new MutliThread("Window 1");4 MutliThread m2=new MutliThread("Window 2");5 MutliThread m3=new MutliThread("Window 3");6 m1.start();7 m2.start();8 m3.start();9 }10 }

    1 public class MutliThread extendsThread {2 private int ticket=100;//每个线程都拥有100张票

    3

    4 publicMutliThread (){}5 publicMutliThread (String name){6 super(name);7 }8

    9 @Override10 public voidrun() {11 while(ticket>0){12 System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());13 }14 }15 }

    程序中定义一个线程类,它扩展了Thread类。利用扩展的线程类在MutliThreadDemo类的主方法中创建了三个线程对象,并通过start()方法分别将它们启动。

    从结果可以看到,每个线程分别对应100张电影票,之间并无任何关系,这就说明每个线程之间是平等的,没有优先级关系,因此都有机会得到CPU的处理。但是结果

    显示这三个线程并不是依次交替执行,而是在三个线程同时被执行的情况下,有的线程被分配时间片的机会多,票被提前卖完,而有的线程被分配时间片的机会比较

    少,票迟一些卖完。

    可见,利用扩展Thread类创建的多个线程,虽然执行的是相同的代码,但彼此相互独立,且各自拥有自己的资源,互不干扰。

    2、通过实现Runnable接口来创建多线程

    1 public classMutliThreadDemo {2 public static voidmain(String[] args) {3 MutliThread m1=new MutliThread("Window 1");4 MutliThread m2=new MutliThread("Window 2");5 MutliThread m3=new MutliThread("Window 3");6 Thread t1=newThread(m1);7 Thread t2=newThread(m2);8 Thread t3=newThread(m3);9 t1.start();10 t2.start();11 t3.start();12 }13 }

    1 public class MutliThread implementsRunnable{2 private int ticket=100;//每个线程都拥有100张票

    3 privateString name;4 MutliThread(String name){5 this.name=name;6 }7 public voidrun(){8 while(ticket>0){9 System.out.println(ticket--+" is saled by "+name);10 }11 }12 }

    由于这三个线程也是彼此独立,各自拥有自己的资源,即100张电影票,因此程序输出的结果和 1 结果大同小异。均是各自线程对自己的100张票进行单独的处理,互不影响。

    可见,只要现实的情况要求保证新建线程彼此相互独立,各自拥有资源,且互不干扰,采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。

    3、通过实现Runnable接口来实现线程间的资源共享

    现实中也存在这样的情况,比如模拟一个火车站的售票系统,假如当日从A地发往B地的火车票只有100张,且允许所有窗口卖这100张票,那么每一个窗口也相当于一个线程,但是这时和前面的例子不同之处就在于所有线程处理的资源是同一个资源,即100张车票。如果还用前面的方式来创建线程显然是无法实现的,这种情况该怎样处理呢?看下面这个程序,程序代码如下所示:

    1 public classMutliThreadDemo {2 public static voidmain(String[] args) {3 MutliThread m=newMutliThread();4 Thread t1=newThread(m);5 Thread t2=newThread(m);6 Thread t3=newThread(m);7 t1.start();8 t2.start();9 t3.start();10 }11 }

    1 public class MutliThread implementsRunnable{2 private int ticket=100;//每个线程都拥有100张票

    3 public voidrun(){4 while(ticket>0){5 System.out.println(ticket--+" is saled by "+Thread.currentThread());6 }7 }8 }

    结果正如前面分析的那样,程序在内存中仅创建了一个资源,而新建的三个线程都是基于访问这同一资源的,并且由于每个线程上所运行的是相同的代码,因此它们执行的功能也是相同的。

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

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

    展开全文
  • Java创建线程的两种方法 目录 继承Thread类的方式 实现Runnable接口的方式 自定义线程 继承Thread类 在Java中要实现线程最简单的方式就是扩展Thread类重写其中的run方法方法原型如下 Thread类中的run方法本身并不...
  • 要产生一个线程,有两种方法:◆需要从Java.lang.Thread类派生一个新的线程类,重载它run()方法;◆实现Runnalbe接口,重载Runnalbe接口中run()方法。哪种方法更好:在Java中,类仅支持单继承,也就是说,当定义...

    要产生一个线程,有两种方法:

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

    哪种方法更好:

    在Java中,类仅支持单继承,也就是说,当定义一个新的类的时候,它只能扩展一个外部类.这样,如果创建自定义线程类的时候是通过扩展 Thread类的方法来实现的,那么这个自定义类就不能再去扩展其他的类,也就无法实现更加复杂的功能。如果自定义类必须扩展其他的类,那么就可以使用实现Runnable接口的方法来定义该类为线程类,这样就可以避免Java单继承所带来的局限性。

    还有一点最重要的就是使用实现Runnable接口的方式创建的线程可以处理同一资源,从而实现资源的共享。

    而利用扩展Thread类创建的多个线程,虽然执行的是相同的代码,但彼此相互独立,且各自拥有自己的资源,互不干扰。

    所以,如果现实的情况要求保证新建线程彼此相互独立,各自拥有资源,且互不干扰,采用哪个方式来创建多线程都是可以的。

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

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

    展开全文
  • 在Java中创建一个线程两种方法:继承Thread类和实现Runnable接口。下面通过两个例子来分析两者区别:1)继承Thread类public class TestThread extends Thread {int count = 3;public TestThread(String ...
  • Java创建线程的两种方法 记录一下java创建线程的两种方法,算是线程的基础入门,但是线程的处理远远不止这些。 1、继承Thraad类。 a) 我们可以通过继承Thread类来创建一个线程 b)接下来我们使用创建ThreadTest...
  • java创建线程的两种方法本人小白一枚,初学java。感觉java学起来非常自然,写起程序来思路也很清晰,刚刚学完多线程编程一块,所以想将一些比较重点的知识点写下来,防止遗忘。java中创建一个线程有两种方法: 继承...
  • 在Java中创建线程和创建普通对象操作是一样,我们可以通过两种方式来创建线程:继承Thread类,并重写run()方法。实现Runnable接口,并实现run()方法方法一:继承Thread类代码非常简单首先重载一个构造函数...
  • 这篇文章主要介绍了简单了解Java创建线程两种方法,文中通过示例代码介绍非常详细,对大家学习或者工作具有一定参考学习价值,需要朋友可以参考下Java实现并启动线程有两种方法1、写一个类继承自Thread类,...
  • Java提供了线程类Thread来创建多...要产生一个线程,有两种方法:◆需要从Java.lang.Thread类派生一个新的线程类,重载它run()方法;◆实现Runnalbe接口,重载Runnalbe接口中run()方法。为什么Java要提供两种方...
  • Java学习笔记:创建线程的两种方法 一、预备工作 1、创建Maven项目ThreadDemo 2、在pom.xml里添加依赖 二、继承Thread类创建子线程 package net.hw.thread; import org.apache.commons.logging.Log; ...
  • 创建线程的两种方法: 1、Runnable接口 2、Thread继承 适用条件: Runnable接口:java只允许单继承,如果一个类已经继承了Thread,就不能再继承其它类,在这种情况下就被迫实现了Runnable的方法。 Thread继承:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,460
精华内容 2,584
关键字:

创建线程的两种方法