精华内容
下载资源
问答
  • 1.、创建线程有哪两种方式? 两种方式: 继承Thread类 实现Runnable接口 2.如何通过继承Thread类来创建线程? 步骤: (1). 定义一个类,继承自Thread类,重写run()方法 (2). 创建该类的实例,即创建一个线程 (3)....

    2.创建线程方式一_继承Thread类:创建线程有哪四种方式???如何通过继承Thread类来创建线程???Thread常用方法有哪四个???

    学习:第7遍


    1.、创建线程有哪四种方式???

    方式一:继承Thread类
    方式二:实现Runnable接口
    方式三:实现Callable接口
    方式四:使用Executors工具类创建线程池


    2.如何通过继承Thread类来创建线程???

    步骤:
    (1). 定义一个类,继承自Thread类,重写run()方法
    (2). 创建该类的实例,即创建一个线程
    (3).调用start()方法,启动线程(不能直接调用run()方法)


    3.Thread常用方法有哪四个???

    方法一:thread1 .setName(“线程1”)
    作用:给线程设置名字

    方法二: thread1.start()
    作用: 启动线程,并直接调用run()方法

    方法三: Thread.currentThread()
    作用:获取当前的线程对象

    方法四: thread .getName()
    作用:调用getName()获取线程名


    
    /*
     * JVM启动时会创建一个主线程,用来执行main方法
     * 要想实现多线程,需要在主线程中创建新的线程
     * 
     * 实际上,Java程序在运行时至少会启动两个线程:main线程、垃圾回收线程gc
     */
    public class TestThread {
    	public static void main(String[] args) {
    
    		// 创建线程
    		MyThread thread1 = new MyThread(); //自定义线程的默认名称:Thread-编号,编号从0开始
    	   /**
    		 * 方法:thread1 .setName("线程1")
    		 * 作用:给线程设置名字
    		 */
    		thread1 .setName("线程1");
    		/**
    		 * 方法:	thread1.start()
    		 * 作用:   启动线程,并直接调用run()方法
    		 */
    		
    		thread1.start(); // 线程并不一定立即执行,要获取到CPU时间片才会执行
    		
    		MyThread thread2 = new MyThread("线程2");
    		thread2.start();
    
           /**
    		 * 方法: Thread.currentThread()
    		 * 作用:获取当前的线程对象
    		 */
    		Thread thread = Thread.currentThread(); 
    		t.setName("主线程");
    		for (int i = 1; i <= 10000; i++) {
    			System.out.println(thread .getName()+"------------" + i); //主线程的默认名称就是main
    		}
    	}
    }
    
    class MyThread extends Thread {
    	
    	public MyThread(){
    		
    	}
    	
    	public MyThread(String name){
    		super(name); //调用父类的构造方法,指定线程名
    	}
    
    	// 在run()方法中编写线程要执行的代码
    	@Override
    	public void run() {
    		for (int i = 1; i <= 10000; i++) {
    			System.out.println(getName()+"------------" + i); // 调用getName()获取线程名
    		}
    	}
    }
    
    
    展开全文
  • 这个问题一般会出现在面试当中,多线程创建有哪种方式呢?答:实现Runable接口和实现Thread类。 我们先看看看实现这两种的实现方式 1 package com.summer; 2 3 public class ThreadA implements ...

    这个问题一般会出现在面试当中,多线程创建有哪几种方式呢?
    答:实现Runable接口和实现Thread类。

    我们先看看看实现这两种的实现方式

     1 package com.summer;
     2 
     3 public class ThreadA implements Runnable {
     4 
     5     public void run() {
     6         System.out.println("start ThreadA!");
     7     }
     8 
     9     public static void main(String[] args) {
    10         Thread thread = new Thread(new ThreadA());
    11         thread.start();
    12     }
    13 }

     

     1 package com.summer;
     2 
     3 public class ThreadB extends Thread {
     4 
     5     @Override
     6     public void run() {
     7         System.out.println("start ThreadB!");
     8     }
     9 
    10     public static void main(String[] args) {
    11         ThreadB threadB = new ThreadB();
    12         threadB.start();
    13     }
    14 }

     

    那么除了这两种方式以外还有什么其他方式呢?

    答:可以实现Callable接口和线程池来创建线程。

     1 package com.summer;
     2 
     3 import java.util.concurrent.Callable;
     4 import java.util.concurrent.FutureTask;
     5 
     6 public class ThreadC implements Callable {
     7 
     8     public Object call() throws Exception {
     9         System.out.println("start ThreadC!");
    10         return null;
    11     }
    12 
    13     public static void main(String[] args) {
    14         ThreadC threadC = new ThreadC();
    15         FutureTask futureTask = new FutureTask(threadC);
    16         Thread thread = new Thread(futureTask);
    17         thread.start();
    18     }
    19 }

     

     1 package com.summer;
     2 
     3 import java.util.concurrent.ExecutorService;
     4 import java.util.concurrent.Executors;
     5 
     6 public class ThreadD implements Runnable {
     7 
     8     public void run() {
     9         System.out.println("start ThreadD!");
    10     }
    11 
    12     public static void main(String[] args) {
    13         ExecutorService executorService = Executors.newSingleThreadExecutor();
    14         executorService.execute(new ThreadD());
    15     }
    16 }

    转载于:https://www.cnblogs.com/tanyang/p/11176103.html

    展开全文
  •    在看很多的关于java创建新线程的博客中,发现有的说创建新的线程有两种方式,有的说是三种方式。但是到底是一种是正确的呢 ? 两种创建方式: 一种是将类声明为Thread的子类,该类应重写Thread类的run方法,...

       在看很多的关于java创建新线程的博客中,发现有的说创建新的线程有两种方式,有的说是三种方式。但是到底是哪一种是正确的呢

    • 两种创建方式: 一种是将类声明为Thread的子类,该类应重写Thread类的run方法,另一种是实现Runnable接口,并实现run方法。
    • 三种创建方式: 在前面两种的方式+ 第三种:实现Callable< V > 接口,实现call方法。

       首先是从这两种结论可以看出:争论是在第三种实现Callable接口的方式 是不是java创建线程的方式!

    我还是先看脚踏实地看下这三种创建新的线程的方式:

    一. 将类声明为Thread的子类,并重写Thread类的run方法

     private static class ThreadSon extends Thread{
            @Override
            public void run(){
                System.out.println("thread子方法:" + Thread.currentThread().getName());
            }
        }
    
        public static void main(String[] args) {
            System.out.println("main方法:" + Thread.currentThread().getName());
            ThreadSon threadSon = new ThreadSon();
            threadSon.start();
        }
    

    执行结果:
    在这里插入图片描述

    二. 实现Runnable接口,重写fun方法

      private static class RunnableSon implements Runnable{
            @Override
            public void run() {
                System.out.println("runable子方法:" + Thread.currentThread().getName());
            }
        }
        
        public static void main(String[] args) {
            System.out.println("main方法:" + Thread.currentThread().getName());
            RunnableSon runnableSon = new RunnableSon();
            Thread t = new Thread(runnableSon);
            t.start();
        }
    

    执行结果:
    在这里插入图片描述

    三. 实现Callable接口,实现call方法

    private static class CallableSon  implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            System.out.println("子线程名称:" + Thread.currentThread().getName());
            return 123456;
        }
    }
    
    public static void main(String[] args) {
        System.out.println("主线程:" + Thread.currentThread().getName());
        CallableSon callableSon = new CallableSon();
        FutureTask<Integer> futureTask = new FutureTask<>(callableSon);
        Thread thread = new Thread(futureTask);
        thread.start();
    }
    

    执行结果:
    在这里插入图片描述
      从上面的运行结果上看,这三种方式都创建了新的线程,那么 “三种创建方式”的结论是正确的。然而事实真的是这样的吗?????

    四. 查看JDK文档

    在这里插入图片描述
      由上图可知,JDK官方文档上明确说明,有两种方式创建一个新的执行线程
      由下图可知,这两种方式,一种是继承Thread,重写run方法;另一种实现Runnable接口,实现run方法。
      由此说明,java创建新的线程的方式是两种!!!
    在这里插入图片描述

    五. 探究:为什么实现Callable接口的方式不被JDK官方承认这是一种新的创建线程的方式呢??

    private static class RunnableSon implements Runnable{
        @Override
        public void run() {
            System.out.println("runnable子方法:" + Thread.currentThread().getName());
        }
    }
    
    private static class CallableSon  implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            System.out.println("callable子方法:" + Thread.currentThread().getName());
            return 123456;
        }
    }
    public static void main(String[] args) {
        System.out.println("主线程:" + Thread.currentThread().getName());
        CallableSon callableSon = new CallableSon();
        FutureTask<Integer> futureTask = new FutureTask<>(callableSon);
        Thread thread = new Thread(futureTask);
        thread.start();
    
        RunnableSon runnableSon = new RunnableSon();
        Thread runThread = new Thread(runnableSon);
        runThread.start();
    }
    

      由上面的代码可知:Runnable和Callable都是通过new Thread(Runnable target)创建线程的,下面代码是Thread的含参构造,并初始化一个线程。

    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    

      下面是Callable的官方说明,Callable类似与Runnable,并由他们共同使用同一个初始化线程的方法。又因为Runnable Jdk1.0 就已经出现,而Callable Jdk1.5才出现,因此JDK官方也只是把他们俩算作一种创建线程的方式。
    在这里插入图片描述

    6. java 创建新的线程的方式是两种:一种是将类声明为Thread的子类,该类应重写Thread类的run方法,另一种是实现Runnable接口,并实现run方法。

      以上第五部分是本人查看源码的理解:如有偏差或错误,请不吝赐教!!!

    展开全文
  • 创建线程有两种方法,一种是继承Thread类创建线程类,而另外一种是实现Runnable接口创建线程类。那么这两种方法本质上有什么区别呢?我们平时更倾向于种呢?下面我们就来讨论下着两种方法的优势与劣势; 1).继承...
    创建线程有两种方法,一种是继承Thread类创建线程类,而另外一种是实现Runnable接口创建线程类。那么这两种方法本质上有什么区别呢?我们平时更倾向于哪种呢?下面我们就来讨论下着两种方法的优势与劣势;

    1).继承Thread类创建线程类  实现Runnable接口创建线程类

    public class Thread1 extends Thread{
    	@Override
    	public void run() {
    		while(true){
    			System.out.println("1" + Thread1.currentThread().getName());
    			try {
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			
    		}
    	}
    
    	public static void main(String[] args) {
    		Thread1 th = new Thread1();
    		th.start();
    
    	}
    }

    2).实现Runnable接口创建线程类

    public class Thread2 implements Runnable {
    	@Override
    	public void run() {
    		while (true) {
    			System.out.println("线程"+ Thread.currentThread().getName());
    			try {
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			
    
    		}
    
    	}
    
    	public static void main(String[] args) {
    		Thread2 th2 = new Thread2();
    		Thread th1 = new Thread(th2);
    		th1.start();
    		
    
    	}
    
    }

    那么这两种方法有什么区别呢?

    先来说说第一种吧:

    采用继承Thead类实现多线程:

    优势:编写简单,如果需要访问当前线程,只需使用this即可,无需使用Thead.currentThread()方法。

    劣势:因为这种线程类已经继承了Thead类,所以不能再继承其它类。

    第二种方法:

    采用实现Runable接口的多线程:

    优势:线程类只是实现了Runable接口,因此还可以继承其他类;

             在这种情况下,可以使多个线程共享一个target对象,所以非常适合多个线程用来处理同一份资源的情况,从而可以将cpu、代码和数据分开,形成清晰的模型,较好的体现面向对象思想。

    劣势:编程略有些复杂,如果要访问当前线程必须使用Thread.currentThread方法。











    展开全文
  • 线程创建有两种方式创建一个类,继承自Java里的Thread类,并重写run方法。 最后再创建自定义线程的对象,并调用start方法,这样就启动一个线程了。 那么Thread到底是个什么东西呢? 一、Thread类 在Java...
  • 抛开线程池不说,创建线程有两种方式 创建线程的第一种方式: 创建一个类继承Thread 重写Thread中的run方法 (创建线程是为了执行任务任务代码必须有存储位置,run方法就是任务代码的存储位置。) 创建子类对象...
  • 线程同步自己及基本就用过Thread和Runnable这两种方式,还有其他很多方式如下: Executor框架简介 创建线程有几种不同的方式?你喜欢一种?为什么? 而线程同步会用的方式就更少了,只会synchronized,其他方式...
  • 两种方式创建线程

    2017-04-10 18:01:03
    线程编程–两种方式创建多线程 ### 目的 创建线程,即拿到一个线程实例。这个线程实例必须具备开启、等待、唤醒等控制自身生命周期的方法。 ### 创建线程 为什么Java要提供两种方法来创建线程呢?它们都哪些区别...
  • 面试官:“你知道有哪几种创建线程方式吗?”(此时你的心理活动:哈哈小意思这能难住我,忍住激动假装淡定道)你:“嗯,可以通过实现 Runnable 接口和继承 Thread 类来创建线程。”面试官:“除了这两种还有其他...
  • 在开发中经常碰到这样一情况,就是使用一个已经继承了某一个类的子类创建线程,由于一个类不能同时有两个父类,所以不能用继承Thread类的方式,那么就只能采用实现Runnable接口的方式。现在大部分的多线程
  • 两种方式本质的对比1. Runnable:最终调用的是target(也就是Runnable接口的实现类)的run方法。2. Thread:直接重写了Thread类的整个run方法同时使用Runnable接口以及Thread类实现线程,会发生什么?面向对象的角度...
  • 面试官:“你知道有哪几种创建线程方式吗?”(此时你的心理活动:哈哈小意思这能难住我,忍住激动假装淡定道)你:“嗯,可以通过实现 Runnable 接口和继承 Thread 类来创建线程。”面试官:“除了这两种还有其他...
  • 对于这两种,也分别有两种启动线程方式: 1)继承Thread类,implements Runnable接口 2)实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现返回结果的线程 ...
  • 面试官:“你知道有哪几种创建线程方式吗?”(此时你的心理活动:哈哈小意思这能难住我,忍住激动假装淡定道)你:“嗯,可以通过实现 Runnable 接口和继承 Thread 类来创建线程。”面试官:“除了这两种还有其他...
  • 进程和线程 对上图说明如下: 方法区和堆是在一个进程内的,即多个线程共享 虚拟机栈和程序计数器每个线程属于自己的一套 理解:进程相当于大家合租房子,...那么,哪种方式更快呢? 是方案一,因为同时移动
  • Java线程创建

    2012-10-19 17:08:36
    实际上Runnable接口只有一个run方法,Thread也是实现了Runnable接口的,但是无论种方式都必须借助Thread类,下面列举了创建线程两种方式: -&gt;方式一:继承Thread类 public class ChildThread extends ...
  • java多线程

    2018-06-10 20:59:45
    一、Java线程的概念在大多数操作系统中都可以...创建线程必须编写一个线程类,用JAVA编写多线程代码有两种方式:第一种方式是直接继承java的线程类Thread;第二种是实现Runnable接口。无论种方式均需要在程序...
  • 线程学习笔记

    2016-08-02 16:52:08
    线程创建有两种方式,无论是一种,都包含run()方法,线程的任务就定义在run()方法中 1.继承Thread类 public class DemoThread extends Thread{ //重写其run()方法 public void run(){ for(int i=0;i10000;i+...
  • 4.创建线程有哪种方式?5.说以下Runnable和Callable的区别?6.线程都有哪些状态? 多线程 1.并行和并发有什么区别? 并行是指个或多个事件在同一时刻发生在不同实体上。 并发是指个或多个事件在同一时间间隔...
  • 在JAVA中,有两种方法可以创建线程:一种是继承Thread类;另一种是实现Runnable接口。不管采用哪种方式,都要用到JAVA类库中的Thread类及相关方法。本实例将展示如何启动和结束线程 运行代码 import java.util.Date...
  • Java多线程

    2019-04-07 21:16:13
    Java中创建线程有两种方法:继承Thread类或者实现Runnable接口。在使用Runnable接口时,需要建立一个Thread实例。因此无论哪种方式建立线程,都必须建立Thread类或者它子类的实例。 二、继承...
  • 面试题—多线程

    2019-09-18 15:50:14
    4.创建线程有哪种方式? 1.并行和并发有什么区别? 并行是指个或者多个事件在同一时刻发生;而并发是指个或多个事件在同一时间间隔发生。 并行是在不同实体上的多个事件,并发是在同一实体上的多个事件。 -...
  • Qt学习之路---线程启动与关闭

    万次阅读 2018-07-08 19:45:23
     Qt创建线程有两种方式。第一种继承QThread重写run函数,需要注意的是只有run函数才在线程中执行,其它函数被父类直接调用时,它执行所在的线程还是在父类所在的线程中。第二种继承QObject使用moveToThread启动线程...
  • 我们都知道,在java中要想实现多线程,有两种手段,一种是继续Thread类,另外一种是实现...创建线程有几种不同的方式?你喜欢一种?为什么?有三种方式可以用来创建线程:(1)继承Thread类 (2)实现Runnab...
  • Java中启动线程有两种方式,继承Thread类以及实现接口Runnable,由于Java无法实现多重继承,故经常通过实现接口Runnable来创建线程。但是无论种方式创建都可以通过start()和run( )方法来启动线程,下面就来介绍...
  • 使用多线程的好处,在于并行的执行多任务,彼此独立,可以提高执行效率。...实际上Thread类也是实现了Runnable接口的,关于这两种方式,官方给出了解释,选择实现Runnable接口创建线程,更有利于资源的共享,并...
  • 定义一个 Thread 类有两种方式,一是在构造函数中直接调用一个要执行的函数,二是覆盖创建的类中的run()方法。不管种方法定义的Thread类,都要通过内置的start()方法来启动线程。Thread也内置了 is_alive()方法...
  • 实现一个线程方式有两种:继承Thread类。实现Runnable接口(也存在说三种的情况,第三种是使用线程并发库中的线程池创建一个线程)。这两种方法都需要重写Run方法,具体的线程逻辑代码写在Run方法中。其实Thread类...

空空如也

空空如也

1 2 3 4 5 6
收藏数 103
精华内容 41
关键字:

创建线程有哪两种方式