精华内容
下载资源
问答
  • java 创建线程有以下几种方式继承 Thread 类创建线程类步骤如下:定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务。因此把run()方法称为线程执行体创建Thread子类的实例...

    Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例。java 创建线程有以下几种方式

    继承 Thread 类创建线程类

    步骤如下:

    定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务。因此把run()方法称为线程执行体

    创建Thread子类的实例,即创建了线程对象

    调用线程对象的start()方法来启动该线程。

    public class FirstThread extends Thread {

    // 线程类的成员变量 不同线程无法共享此变量

    private int i;

    @Override

    public void run() {

    for (; i < 3; i++) {

    // 重写 run 方法,在线程创建时就会执行此方法

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

    }

    }

    public static void main(String[] args) {

    for (int i = 0; i < 5; i++) {

    // 获取当前线程

    System.out.println(Thread.currentThread().getName());

    if (i == 2) {

    // 创建并启动第1个线程

    new FirstThread().start();

    // 创建并启动第2个线程

    new FirstThread().start();

    }

    }

    }

    }

    d19ce4ce107bcc9662fa77f93342b7d4.png

    多线程有个特征,执行的结果是不可预测的,这跟线程的生命周期有关,接下来会详解。我们启动线程时,系统并不会立即执行该线程,而是将其设为就绪状态。什么时候执行对于码农是透明的

    在默认情况下,主线程的名字为main,用户启动的多个线程的名字依次为Thread-0、Thread-1、Thread-2、…、Thread-n等。

    不要直接调用 run 方法

    public class InvokeRun extends Thread {

    private int i;

    @Override

    public void run() {

    for (; i < 3; i++) {

    // 直接调用 run 方法时,Thread 的 this.getName() 返回的是该对象的名字,而不是当前线程的名字

    System.out.println(Thread.currentThread().getName() + " " + i);

    }

    }

    public static void main(String[] args) {

    for (int i = 0; i < 5; i++) {

    System.out.println(Thread.currentThread().getName() + " " + i);

    if (i == 2) {

    // 直接调用线程的 run 方法,会被当成普通方法,所以以下并不会启动两个线程

    new InvokeRun().run();

    new InvokeRun().run();

    }

    }

    }

    }

    7c24ca18aabd61cff7b3ab959935d21a.png

    展开全文
  • 一、Java创建线程的两种方式继承Thread类实现Runnable接口两种方法都需要重写run()方法之后调用start()方法让线程进入准备状态。(具体执行时间由cpu调度,start()方法并非真正的执行方法)。继承Thread类Thread类...

    一、Java创建多线程的两种方式

    继承Thread类

    实现Runnable接口

    两种方法都需要重写run()方法之后调用start()方法让线程进入准备状态。(具体执行时间由cpu调度,start()方法并非真正的执行方法)。

    继承Thread类

    Thread类本身也是实现了Runnable接口,重写了run()方法,Thread类可直接实例化线程对象

    package test;

    import org.junit.Test;

    /**

    * @ClassName: test1

    * @Description: TODO

    * @Author: JL

    * @Date: 2019/2/18 17:46

    * @Version 1.0

    */

    public class test1 {

    @Test

    public void test(){

    new ThreadTest().start();

    new ThreadTest().start();

    new ThreadTest().start();

    new ThreadTest().start();

    new ThreadTest().start();

    }

    class ThreadTest extends Thread{

    //继承Thread类,重写run()方法

    @Override

    public void run() {

    System.out.println(Thread.currentThread().getName()+"执行Start");

    System.out.println(Thread.currentThread().getName()+"执行End");

    }

    }

    }

    复制代码

    实现Runnable接口

    实例化Runnable接口的实现类对象,作为Thread类的构造器参数生成线程对象。

    @Test

    public void t2(){

    ThreadTest1 runnable = new ThreadTest1();

    new Thread(runnable).start();

    new Thread(runnable).start();

    new Thread(runnable).start();

    new Thread(runnable).start();

    new Thread(runnable).start();

    }

    class ThreadTest1 implements Runnable{

    //实现Runnable接口,实现run()方法

    @Override

    public void run() {

    System.out.println(Thread.currentThread().getName()+"执行Start");

    System.out.println(Thread.currentThread().getName()+"执行End");

    }

    }

    复制代码

    总结:java中存在单继承、多实现的特性,所以我们在开发过程中尽量使用实现Runnable接口,而非继承Thread类。

    展开全文
  • Java如何创建线程

    2019-03-19 17:20:35
    两种方法都需要重写run()方法之后调用start()方法让线程进入准备状态。(具体执行时间由cpu调度,start()方法并非真正的执行方法)。 继承Thread类 Thread类本身也是实现了Runnable接口,重写了run()方法,Thread...

    一、Java创建多线程的两种方式

    • 继承Thread类
    • 实现Runnable接口

    两种方法都需要重写run()方法之后调用start()方法让线程进入准备状态。(具体执行时间由cpu调度,start()方法并非真正的执行方法)。

    继承Thread类

    Thread类本身也是实现了Runnable接口,重写了run()方法,Thread类可直接实例化线程对象

    package test;
    
    
    import org.junit.Test;
    
    
    /**
     * @ClassName: test1
     * @Description: TODO
     * @Author: JL
     * @Date: 2019/2/18 17:46
     * @Version 1.0
     */
    public class test1 {
        @Test
        public void test(){
            new ThreadTest().start();
            new ThreadTest().start();
            new ThreadTest().start();
            new ThreadTest().start();
            new ThreadTest().start();
        }
    
        class ThreadTest extends Thread{
            //继承Thread类,重写run()方法
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行Start");
                System.out.println(Thread.currentThread().getName()+"执行End");
            }
        }
    }
    

    实现Runnable接口

    实例化Runnable接口的实现类对象,作为Thread类的构造器参数生成线程对象。

       @Test
        public void t2(){
            ThreadTest1 runnable = new ThreadTest1();
            new Thread(runnable).start();
            new Thread(runnable).start();
            new Thread(runnable).start();
            new Thread(runnable).start();
            new Thread(runnable).start();
        }
    
        class ThreadTest1 implements Runnable{
            //实现Runnable接口,实现run()方法
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行Start");
                System.out.println(Thread.currentThread().getName()+"执行End");
            }
        }

    总结:java中存在单继承、多实现的特性,所以我们在开发过程中尽量使用实现Runnable接口,而非继承Thread类。

     

    展开全文
  • Java线程创建和启动

    2016-04-16 11:25:59
    Java使用Thread类表示线程,所有的线程对象必须是Thread类或子类的实例。继承Thread类创建线程类步骤: 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体内就是线程需要完成的任务,称为方法体。 ...

    Java使用Thread类表示线程,所有的线程对象都必须是Thread类或子类的实例。

    继承Thread类创建线程类

    步骤:

    1. 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体内就是线程需要完成的任务,称为方法体。
    2. 创建Thread子类的实例,就是创建线程对象。
    3. 调用线程对象的start()方法来启动该线程。
    public class FirstThread extends Thread
    {
        private int i ;
        // 重写run方法,run方法的方法体就是线程执行体
        public void run()
        {
            for ( ; i < 100 ; i++ )
            {
                // 当线程类继承Thread类时,直接使用this即可获取当前线程
                // Thread对象的getName()返回当前该线程的名字
                // 因此可以直接调用getName()方法返回当前线程的名
                System.out.println(getName() +  " " + i);
            }
        }
        ...........
                    //创建、并启动第一条线程
                    new FirstThread().start();              
                    // 创建、并启动第二条线程
                    new FirstThread().start();
    

    当使用本方法创建线程时,可以直接使用this获取当前线程。

    线程还有以下方法:
    Thread.currentThread():currentThread()是Thread类的静态方法,该方法返回当前正在执行的线程对象。
    getName():该方法是Thread类的实例方法,返回的是该方法的线程名字。
    setName(String name):为线程设置名字。

    多线程运行结果
    红色的标记可以看出两个线程不是连续的,说明没有共享数据。所以使用此方法创建的线程类,多个线程之间无法共享线程类的实例变量

    只有调用start()方法,系统才会把run()方法当成线程执行体。如果直接调用run()方法,系统把线程对象当成普通对象,且run()方法当成普通方法。

    实现Runnable接口创建线程类

    步骤:

    1. 定义Runnable接口的实现类,并重写该接口的run()方法。
    2. 创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread的对象,此对象才是真正的线程对象。
    3. 调用线程对象的start()方法启动该线程。
    public class SecondThread implements Runnable
    {
        private int i ;
        // run方法同样是线程执行体
        public void run()
        {
            for ( ; i < 100 ; i++ )
            {
                // 当线程类实现Runnable接口时,
                // 如果想获取当前线程,只能用Thread.currentThread()方法。
                System.out.println(Thread.currentThread().getName()
                    + "  " + i);
            }
        }
    
        .....
                {
                    SecondThread st = new SecondThread();     
                    // 通过new Thread(target , name)方法创建新线程
                    new Thread(st , "新线程1").start();
                    new Thread(st , "新线程2").start();
                }
    

    实现Runnable接口获得当前线程对象,则必须使用Thread.currentThread()方法。
    采用本方法,可以实现线程之间共享数据。
    这里写图片描述

    使用Callable和Future创建线程

    此方法可以把任意方法包装成线程执行体,而不像前两种方法都需要把Thread类的run()方法包装成线程执行体。
    Callable接口提供一个call()方法作为线程执行体,但是此方法有返回值,且可以抛出异常。
    但是Callable接口不是Runnable的子接口,Callable对象无法直接作为Thread的target。于是使用FutureTask类的Future接口来代表Callable接口里的call()方法的返回值,且FutureTask类也实现了Runnable接口,所以就可以作为Thread类的target。

    步骤:

    1. 创建Callable接口实现类,并实现call()方法,该call()方法有返回值,再创建Callable实现类的实例。从Java8开始,可以直接使用lambda表达式创建Callable对象。
    2. 使用FutureTask来包装Callable对象。该FutureTask对象封装该Callable对象的call()方法返回值。
    3. 使用FutureTask对象作为Thread对象的target创建并启动线程。
    4. 调用FutureTask对象的get()方法来获得子线程执行结束后返回值。
    public class ThirdThread
    {
        public static void main(String[] args)
        {
            // 创建Callable对象
            ThirdThread rt = new ThirdThread();
            // 先使用Lambda表达式创建Callable<Integer>对象
            // 使用FutureTask来包装Callable对象
            FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)() -> {
                int i = 0;
                for ( ; i < 100 ; i++ )
                {
                    System.out.println(Thread.currentThread().getName()
                        + " 的循环变量i的值:" + i);
                }
                // call()方法可以有返回值
                return i;
            });
            for (int i = 0 ; i < 100 ; i++)
            {
                System.out.println(Thread.currentThread().getName()
                    + " 的循环变量i的值:" + i);
                if (i == 20)
                {
                    // 实质还是以Callable对象来创建、并启动线程
                    new Thread(task , "有返回值的线程").start();
                }
            }
            try
            {
                // 获取线程返回值
                System.out.println("子线程的返回值:" + task.get());
            }
            catch (Exception ex)
            {
                ex.printStackTrace();
            }
        }
    }

    三种方法对比

    实现Runnalbe接口与实现Callable接口方式基本相同,只是Callable接口可以有返回值,可以抛出异常,所以归为一类。
    实现Runnale,Callable接口方法的优缺点:

    优点:
    1. 可以继承其他类。
    2. 适合多个相同线程来处理同一份资源。

    缺点:
    访问当前线程,都需要使用Thread.currentThread()方法。

    继承Thread类方法:

    优点:
    编写简单,访问当前线程,只需要使用this即可。

    缺点:
    无法继承其他类。

    展开全文
  • 在第一节中,对线程创建我们通过看文档,得知线程创建有两种方式进行实现,我们进行第一种方式的创建,通过继承Thread 类 ,并且重写它的run 方法,就可以进行线程创建,所有的程序执行放在了run 方法里;...
  • java创建线程三种方法

    2020-05-29 12:47:14
    java创建线程的三种方法 Java使用Thread类代表线程,所有的线程对象必须...(1)d定义Thread类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务,run()方法也称为线程执行体。 (2)创建Thread子类
  • 定义Therad类的子类,并重写该类的Thread方法,该run()方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体; 创建Thread子类的实例,即创建线程对象; 3) 调用线程的start()方法来启动该线程; start...
  • Java线程创建和启动

    2016-09-15 17:30:09
    Java使用Thread类代表线程,所有线程对象必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务,实际上...①定义Thread类的子类,并重写改类的run()方法,该run()方法体就代表了线程需要完成的任务,因此把
  • Java线程创建

    2020-10-27 15:06:11
    做实验的过程中需要用到多线程,许久不用有点儿生疏了,现在查资料做个多线程创建的方法记录。...每次创建一个新的线程都需要新建一个Thread子类的对象。 一个线程调用两次start()方法将会抛出线程状态异常。 继承Th
  • Java线程 - 线程创建和启动

    千次阅读 2018-06-06 23:26:27
    线程创建一般有以下三种:一、继承Thread类创建线程类定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此经常把run()方法称为线程执行体。创建Thread子类的...
  • JAVA线程学习

    2017-05-09 15:33:31
    无论使用哪种方法,都需要重写run方法,然后将它new出来。如果是继承Thread方法创建线程,则直接使用new出来的对象;如果是实现Runnable方法创建线程,需要将new出来的对象做为参数创建线程。 packag
  • 文章目录java线程线程创建两种方式创建线程模拟排队机叫号排队线程生命周期线程中一些常用方法构造方法Runable 参数传值...两种方式都需要重写run方法 启动线程调用start()方法 创建线程 这里继承Threa...
  • 因为使用此方法创建线程类,此线程类需要继承 Thread类并重写 Thead类的un()方法因为 Tivend类的n()方法是线程要执行操作任务的方法,所以线程要执行的操作代码都需要写在run()方法中,并通过调用 start()...
  • java线程机制,一开始我们用的单线程。现在接触到多线程了。多线性首先要解决的问题是:创建线程,怎么创建线程的问题;1、线程创建:四种常用的实现方法1.继承Thread。Thread是java.lang包下面的,所以不需要...
  • 前言 Java使用Thread类代表线程,所有的线程对象...1、定义Thread类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务,run()方法也称为线程执行体 2、创建Thread子类的实例,也就是创建了线
  • Java 线程 1、创建线程类(方法一) Java使用 java.lang.Thread 类代表线程...定义 Thread 类的子类,并重写该类的 run() 方法,该 run() 方法的方法体就代表了线程需要完成的任务,因此把 run() 方法称为线程执行体。
  • Java使用Thread类代表线程,所有的线程对象必须是Thread类或其子类的实例。  一、继承Thread类创建线程类  1.重写run方法。该run()方法的方法体就代表了线程需要完成的任务。  2.创建Thre...
  • java线程详解

    2019-07-12 16:35:18
    线程创建与启动 线程的状态和生命周期 线程的调度 线程同步和死锁 线程创建(简单来说就是继承Thread类或者Runnable接口) 创建一个Thread类,或者一个Thread...线程相关的代码写在该方法中,一般都需要重写 ...
  • java线程模式

    2017-09-13 20:02:03
    有两种创建线程的方法,一个是通过Thread类,一个是通过Runnable接口...java通过Thread类将线程所必须的功能封装起来,想要创建一个线程,只需要创建一个类继承Thread类,然后重写Thread类里的run()方法就可以了。
  • 一 、继承Thread类创建 通过继承Thread类,重写其run方法,run()为线程要执行的任务,因此又称为...每个线程都需要创建不同的Thread类,多个线程间无法共享线程类的实例变量) public class HelloWorldThread ...
  • Java使用Thread类代表线程,所有的线程对象必须是Thread类或其子类的实例。 线程创建一般有以下三种: 一、继承Thread类创建线程类 步骤1.定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就...
  • java使用Thread类代表线程,所有的线程都必须是Thread或者其子类的实例。 每个线程的任务就是完成一定的任务,实际上就是执行一段程序流。   【创建并启动多线程的步骤(集成Thread类方式)】 1.定义继承Thread...
  • java线程的实现

    2020-09-13 22:59:43
    java线程的实现 1-线程的概述 ​ 电脑中运行的每一个程序是由一个进程组成,其中每一个进程又是由一个或者多个线程组成,程序运行实际是线程的运行。 2-创建线程的步骤(方法一) 第一步:创建自己的线程类,...
  • 无论那种方式都需要重写run方法, 虽然Runnable 时强制的, Thread 是非必须的。1. 核心概念1.1 Thread 与 Runnable 的区别使用Thread 创建的类不能继承其它父类, 因为java 中一个类只允许继承...
  • Java线程常用方法

    2019-01-24 14:37:41
    写一个新的线程的时候,都需要重写run方法。但是重写run方法之后并不代表就创建了新的线程。要想启动一个新的线程必须调用start()方法来启动线程。如果直接调用run方法则并没有新的线程产生。此时的run方法和普通的...
  • 需要继承Thread类和接口Runnable方能创建线程,创建的子线程默认情况下是随机和主线程抢占cpu资源进行执行,子线程和主线程两者是竞争关系,每个字线程都是独立开辟栈空间,并且是由主线程执行到.strat()来进行栈...
  • Thread类的run()是线程要执行操作任务的方法,所以线程要执行的操作代码都需要写在run()方法中,并通过调用start()方法来启动线程。    使用Thread类创建线程的优点是简单明了;同时最大的缺点是:如果...
  • Java线程

    2018-03-06 10:57:51
    线程创建 Java 使用 Thread 类代表线程,...定义 Thread 类的子类,并重写该类的 run() 方法,该方法的方法体就是线程需要完成的任务,run() 方法也称为线程执行体 创建 Thread 子类的实例,也就是创建线程对...
  • java创建线程使用 Thread类和Runable接口: 1.不管是类还是接口重写run方法 2.即使是使用了Runnable接口的类,最后也是需要借助Thread类来进行start(); 3.使用Runnable接口可以实现数据的共享,比如车站卖...
  • Thread是创建线程的类,在Java中开启多线程一半都需要经过这个类,Thread开启线程必须要用的方法有两个。一个是run方法,该方法必须被子类重写,只有在该方法中的内容才认为是线程中的内容。另一个是start,该方法是...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 170
精华内容 68
关键字:

创建java线程都需要重写

java 订阅