精华内容
下载资源
问答
  • java runnable

    2020-07-12 17:58:34
    对于多线程的实现方式主要有两种:实现Runnable接口,继承Thread类对于这两种多线程的实现方式也是有着差异的。下面我们来看看怎么通过两种实现方式启动多线程。 Thread: public class MyThread extends Thread { @...

    对于多线程的实现方式主要有两种:实现Runnable接口,继承Thread类对于这两种多线程的实现方式也是有着差异的。下面我们来看看怎么通过两种实现方式启动多线程。
    Thread:

    public class MyThread extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10; i ++){
                System.out.println("子线程在执行" + i);
            }
        }
    }
     public static void main(String[] args) {
            MyThread m = new MyThread();
            //通过调用Thread的start()方法启动子线程
            m.start();
            for (int i = 0;i < 10; i ++){
                System.out.println("主线程在执行" + i);
            }
        }
    

    Runable:

    public class MyRunnable implements  Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10; i ++){
                System.out.println("子线程在执行" + i);
            }
        }
    }
     public static void main(String[] args) {
            //Runnable
            //创建一个任务对象
            MyRunnable my = new MyRunnable();
            //创建一个线程,并为其分配任务
            Thread th = new Thread(my);
            //执行线程
            th.start();
            for (int i = 0;i < 10; i ++){
                System.out.println("主线程在执行!" + i);
            }
        }
    

    实现Runnable 接口
    1.定义类实现Runnable 接口
    2. 覆盖Runnable 接口中的run方法(将线程要运行的代码存放在该run方法中)
    3. 通过Thread 类建立线程对象
    4.将Runnale接口的子类对象作为实际的参数传递给Thread 类的构造函数
    (为什么要Runnable 接口的对象传递给Thread的子类对象?因为要让线程去指定对象的run方法,就必须明确该run方法所属的对象)
    5.调用Thread 类的start方法开启线程并且调用Runnable 接口的子类的run 方法。
    那么为什么有了Thread类还需要有Runable接口呢?这不是多此一举吗?实际上不是的。首先我们要明白java是一个面向对象的语言,其次java只允许单继承,也就是不允许多继承。在实际的开发中,有时候我们需要继承其他的类,所以此时Runable接口就闪亮登场了!实现了Runnable接口的类还可以继承其他的类,还有Runable方便资源的共享,我们把要操作的数据封装入Runnable的实现类中,然后将Runnable实例传入多个Thread对象中,就可以实现一个对象数据在多个线程的共享了。还有Thread本身就是一个Runnable的实现

    当我们的线程的数量多起来的时候,我们也就应该要考虑这些线程的创建和销毁,这很浪费时间,所以我们就需要使用线程池技术来进行管理。然后我们只需要把实现了Runnable类的对象实例去放入线程池中,那么线程池就会自动维护线程的启动,运行,销毁,我们也不需要去调用start()方法来启动这个线程,这也算是Runnable接口的一个好处吧。

    展开全文
  • 主要介绍了java Runnable接口创建线程的相关资料,需要的朋友可以参考下
  • Java认证:JavaRunnable线程编写接口代码。JavaRunnable线程如何才能更好的适应目前的编程环境呢?下面我们就看看如何才能更好的进行相关环境。希望下面的文章对大家有所帮助。JavaRunnable线程接口只有一个方法run...

      Java认证:JavaRunnable线程编写接口代码。JavaRunnable线程如何才能更好的适应目前的编程环境呢?下面我们就看看如何才能更好的进行相关环境。希望下面的文章对大家有所帮助。JavaRunnable线程接口只有一个方法run(),我们声明自己的类实现Runnable接口并提供这一方法。
      将我们的线程代码写入其中,就完成了这一部分 的任务。但是Runnable接口并没有任何对线程的支持,我们还必须创建Thread类的实例,这一点通过Thread类的构造函 数 public Thread(Runnable target);来实现。
      下面是一个例子:
      1.public class MyThread implements Runnable
      2.{
      3.int count= 1, number;
      4.public MyThread(int num)
      5.{
      6.numnumber = num;
      7.System.out.println("创建线程 " + number);
      8.}
      9.public void run()
      10.{
      11.while(true)
      12.{
      13.System.out.println
      14.("线程 " + number + ":计数 " + count);
      15.if(++count== 6) return;
      16.}
      17.}
      18.public static void main(String args[])
      19.{
      20.for(int i = 0; i 〈 5;
      21.i++) new Thread(new MyThread(i+1))。start();
      22.}
      23.}
      严格地说,创建Thread子类的实例也是可行的,但是必须注意的是,该子类必须没有覆盖 Thread 类的 run 方法,否则该线程执行的将是子类的 run 方法,而不是我们用以实现Java Runnable线程接口的类的 run 方法,对此大家不妨试验一下。托福答案 www.jszdsy.com
      使用 Runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码,有利于封装,它的缺点在于,我们只能使用一套代码,若想创建多个线程 并使各个线程执行不同的代码,则仍必须额外创建类,如果这样的话,在大多数情况下也许还不如直接用多个类分别继承 Thread 来得紧凑。
      综上所述,两种方法各有千秋,大家可以灵活运用。下面让我们一起来研究一下多线程使用中的一些问题。
      Java Runnable线程的四种状态 www.yzyxedu.com
      1.新状态:线程已被创建但尚未执行(start() 尚未被调用)。
      2.可执行状态:线程可以执行,虽然不一定正在执行。CPU 时间随时可能被分配给该线程,从而使得它执行。
      3.死亡状态:正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果,但是不被推荐,前者会产生异常,后者是强制终止,不会释放锁。
      4.阻塞状态:线程不会被分配 CPU 时间,无法执行。

    转载于:https://www.cnblogs.com/tianchaoy/p/4101453.html

    展开全文
  • java runnable接口

    千次阅读 2018-11-10 11:17:25
    Runnable 是接口。 Thread 是类,且实现了Runnable接口。 Thread部分源码 public class Thread implements Runnable { private static class Caches { static final ConcurrentMap subclassAudits = new ...

    概述
    Runnable 是接口。

    Thread 是类,且实现了Runnable接口。

    Thread部分源码

    public class Thread
    implements Runnable
    {
    private static class Caches
    {

        static final ConcurrentMap subclassAudits = new ConcurrentHashMap();
        static final ReferenceQueue subclassAuditsQueue = new ReferenceQueue();
    

    在使用Runnable定义的子类中没有start()方法,只有Thread类中才有。

    public interface Runnable
    {

    public abstract void run();
    

    }

    Thread类,有一个构造方法:public Thread(Runnable targer)

    public Thread(Runnable runnable)
    {
        daemon = false;
        stillborn = false;
        threadLocals = null;
        inheritableThreadLocals = null;
        threadStatus = 0;
        blockerLock = new Object();
        init(null, runnable, (new StringBuilder()).append("Thread-").append(nextThreadNum()).toString(), 0L);
    }
    

    此构造方法接受Runnable的子类实例,也就是说可以通过Thread类来启动Runnable实现的多线程。

    使用情况
    在程序开发中只要是多线程肯定永远以实现Runnable接口为主。

    实现Runnable接口相比继承Thread类有如下好处:
    1、避免继承的局限,一个类可以继承多个接口。
    2、适合于资源的共享。

    实例
    以卖票为例,总共只有10张动车票了,全国3个窗口在卖。

    继承Thread类的方法

    package multithreading;

    public class MyThreadWithExtends extends Thread {

    private int tickets = 10;
    
    @Override
    public void run() {
    
    	for (int i = 0; i <= 100; i++) {
    		if(tickets>0){
    			System.out.println(Thread.currentThread().getName()+"--卖出票:" + tickets--);
    		}
    	}
    }
    
    
    public static void main(String[] args) {
    	MyThreadWithExtends thread1 = new MyThreadWithExtends();
    	MyThreadWithExtends thread2 = new MyThreadWithExtends();
    	MyThreadWithExtends thread3 = new MyThreadWithExtends();
    
    	thread1.start();
    	thread2.start();
    	thread3.start();
    	
    	//每个线程都独立,不共享资源,每个线程都卖出了10张票,总共卖出了30张。如果真卖票,就有问题了。
    }
    

    }

    运行结果:
    Thread-0–卖出票:10
    Thread-2–卖出票:10
    Thread-1–卖出票:10
    Thread-2–卖出票:9
    Thread-0–卖出票:9
    Thread-2–卖出票:8
    Thread-1–卖出票:9
    Thread-2–卖出票:7
    Thread-0–卖出票:8
    Thread-2–卖出票:6
    Thread-2–卖出票:5
    Thread-2–卖出票:4
    Thread-1–卖出票:8
    Thread-2–卖出票:3
    Thread-0–卖出票:7
    Thread-2–卖出票:2
    Thread-2–卖出票:1
    Thread-1–卖出票:7
    Thread-0–卖出票:6
    Thread-1–卖出票:6
    Thread-0–卖出票:5
    Thread-0–卖出票:4
    Thread-1–卖出票:5
    Thread-0–卖出票:3
    Thread-1–卖出票:4
    Thread-1–卖出票:3
    Thread-1–卖出票:2
    Thread-0–卖出票:2
    Thread-1–卖出票:1
    Thread-0–卖出票:1

    每个线程都独立,不共享资源,每个线程都卖出了10张票,总共卖出了30张。如果真卖票,就有问题了。

    实现Runnable接口方式

    package multithreading;

    public class MyThreadWithImplements implements Runnable {

    private int tickets = 10;
    
    @Override
    public void run() {
    
    	for (int i = 0; i <= 100; i++) {
    		if(tickets>0){
    			System.out.println(Thread.currentThread().getName()+"--卖出票:" + tickets--);
    		}
    	}
    }
    
    
    public static void main(String[] args) {
    	MyThreadWithImplements myRunnable = new MyThreadWithImplements();
    	Thread thread1 = new Thread(myRunnable, "窗口一");
    	Thread thread2 = new Thread(myRunnable, "窗口二");
    	Thread thread3 = new Thread(myRunnable, "窗口三");
    
    	thread1.start();
    	thread2.start();
    	thread3.start();
    }
    

    }

    运行结果:
    窗口二–卖出票:10
    窗口三–卖出票:9
    窗口一–卖出票:8
    窗口三–卖出票:6
    窗口三–卖出票:4
    窗口三–卖出票:3
    窗口三–卖出票:2
    窗口三–卖出票:1
    窗口二–卖出票:7
    窗口一–卖出票:5

    每个线程共享了对象myRunnable的资源,卖出的总票数是对的,但是顺序是乱的,怎么办?

    作者:曾妙根
    来源:CSDN
    原文:https://blog.csdn.net/zengmingen/article/details/53217229
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • Java Runnable接口

    2019-03-20 14:41:19
    创建线程有三种方法, 其中一种是实现Runnable接口,Runnable接口中只有一个run()方法, 它非Thread类子类提供的一种激活方式. 一个类实现Runnable接口后, 并不代表该类是一个"线程"类, 不能直接运行, 必须通过Thread...

    创建线程有三种方法, 其中一种是实现Runnable接口, Runnable接口中只有一个run()方法, 它非Thread类子类提供的一种激活方式. 一个类实现Runnable接口后, 并不代表该类是一个"线程"类, 不能直接运行, 必须通过Thread实例才能创建并运行线程.

    通过Runnable接口创建线程的步骤是:

    1. 定义Runnable接口的实现类, 一样要重写run()方法, 这个run()方法和Thread中的run()方法一样是线程的执行体

    2. 创建Runnable实现类的实例, 并用这个实例作为Thread的target来创建Thread对象, 这个Thread对象才是真正的线程对象

    3. 第三步是通过调用线程对象的start()方法来启动线程

    class MyThread implements Runnable {
        //重写run()方法
        @Override
        public void run() {
            //获取当前线程的名字
            System.out.println("当前线程" + Thread.currentThread().getName());
            for (int i = 0; i < 30; i++) {
                System.out.println("A");
            }
        }
    }
    
    public class TestRunnable {
        public static void main(String[] args) {
            //创建一个任务对象
            MyThread myThread = new MyThread();
            //将实现的Runnable类的实例传入构造函数
            Thread thread = new Thread(myThread);
            thread.start();
            //获取主线程的名字
            System.out.println("主线程: [" + Thread.currentThread().getName()+"]");
            for (int i = 0; i < 30; i++) {
                System.out.println("C");
            }
    
        }
    }
    

    注意: 直接调用Thread类或Runnable类对象的 run() 方法是无法启动线程的, 这只是一个简单的方法调用, 必须通过Thread方法中的 start() 才可以

     

     

     

    展开全文
  • Java Runnable 接口在学习的时候会有不少的问题让我们不能理解,其实只有一个方法 run(),我们声明自己的类实现 Runnable 接口并提供这一方法,将我们的线程代码写入其中,就完成了这一部分的任务。 但是Java ...
  • Java Runnable和Thread

    2018-04-07 16:46:17
    刚才刷知乎的之后,突然刷到一个问题:Thread与Runnable区别? 然后我看了一下源码,发现Runnable是一个接口: @FunctionalInterface public interface Runnable { public abstract void run(); } 而Thread是...
  • JAVA Runnable接口

    万次阅读 2017-12-19 15:30:40
    class RenWu implements Runnable{ //重写run()方法 public void run() { //获取当前线程的名字 System.out.println("当前线程:"+Thread.currentThread().getName()); for(int i=0;i;i++) { System.o
  • 我们上一篇的Thread能创建线程但是...Java不支持多继承 不对thread中的其他方法进行重写 package Runnableproj; class PrintRunnable implements Runnable{ @Override public void run() { // TODO Auto-...
  • 并行计算----5种方式实现判断是不是素数.Net,Win32,JavaRunnable,OpenMp,JavaThread,本文章不在于学会怎么去判断是不是素数而是在于体会并行计算
  • Java Runnable线程传参,让run访问参数

    千次阅读 2020-05-27 09:12:12
    做Android开发,可能经常要用到Runnable线程,有时候可能需要传参数进去,然后在run函数中取出参数使用。 解决办法 自定义一个接口,继承Runnable,新增一个传参方法 public interface MyRunnable extends Runnable ...
  • 线程池问题中,Runnable 和 Callable 分别要什么时候用?解答。。。
  • 一,概述通过Runable接口实现多线程比继承...二,简单的Runnable接口实现多线程例子本例子模拟了访客访问网站这个事情。package org.maoge.thread; //通过Runnable接口实现多线程 public class RunnableDemo implement
  • 1 class MyThread implements Runnable{ 2 private String name; 3 public MyThread(String name){ 4 this.name=name; 5 } 6 public void run(){ 7 for(int i=0;i 8 Sy
  • class Printer implements Runnable { private String message; public Printer(String message) { this.message = message; } public void run() { for(int i=0; i; i++) { System.out....
  • Java Runnable线程变量共享问题

    千次阅读 2014-12-11 10:14:27
    int i=0; synchronized (this){ for(;i sb.append(i+"\n"); try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace();...jtp.setText(sb.
  • 1、runnable的职责 2、策略模式在thread中的应用 3、模拟营业大厅叫号机程序 ------------------------------------------------------runnable的职责---------------------------------------------------------...
  • 参考了此篇博文(http://blog.csdn.net/liutengteng130/article/details/20036517...其中,就runnable接口实现方法的特性——多线程无差错修改类公共变量值问题,觉得很有价值,对源代码做了批注,拿来分析下和大家共享
  • JavaRunnable

    2019-06-26 17:21:47
    创建线程辅助对象:MyRunnable runnable = new MyRunnable()。 创建线程对象:Thread thread1 = new Thread(runnable, “线程一”);。 调用线程对象的 start() 方法。 public class RunnableDemo { public ...
  • Java 实现 Runnable 接口

    2018-10-01 09:53:33
    Java 继承 Thread 类 一样,实现 Runnable 接口也是启动 Java 线程的一种方式 通过继承 Thread 类实现多线程的对象,不适合资源共享,而实现 Runnable 接口,则适合资源共享 不论是通过继承 Thread 类或者实现 ...
  • java线程 Runnable方式

    千次阅读 2018-07-30 15:24:57
    售票系统:Runnable接口(此处票数不是静态staic) 创建一个类 并实现其Runnable接口 eg: class Test implements Runnable {  private int tick = 100;  public void run(){  while(true){  ...
  • javaRunnable和Callable的区别

    万次阅读 2020-03-11 09:18:36
    javaRunnable和Callable的区别 在java的多线程开发中Runnable一直以来都是多线程的核心,而Callable是java1.5添加进来的一个增强版本。 本文我们会详细探讨Runnable和Callable的区别。 运行机制 首先看下Runnable...
  • java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口;Thread类是在java.lang包中定义的。接下来通过本文给大家浅析JavaRunnable和Thread的区别,一起看看吧
  • JAVA 实现Runnable接口

    千次阅读 2017-12-11 09:10:45
    如有侵权,请作者联系我删除博客,谢谢 //仅作为学习笔记 ...创建线程的第二种方式:实现Runnable接口 步骤: 1,定义类实现Runnable接口 2,覆盖Runnable接口中的run方法 将线程要运
  • Java Thread Runnable run

    2016-09-12 03:13:35
    请问 为什么主函数中的User eclipse 会提示修改成 ... Thread t1 = new Thread(new Runnable(){public void run(){u.A();}}); Thread t2 = new Thread(new Runnable(){public void run(){u.B();}}); } }
  • 主要为大家详细介绍了java实现Runnable接口适合资源的共享,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,466
精华内容 12,586
关键字:

javarunnable

java 订阅