精华内容
下载资源
问答
  • JAVA中,启动线程的三种方法

    千次阅读 2018-06-19 01:32:45
    1、继承Thread类, 重写run方法,在main函数中,调用start方法。代码如下: //播放音乐线程类  class MusicThread extends Thread {   public void run() {   for (int i = 0; ...

    1、继承Thread类, 重写run方法,在main函数中,调用start方法。代码如下:

    1. //播放音乐线程类  

    2. class MusicThread extends Thread {  

    3.     public void run() {  

    4.         for (int i = 0; i < 50; i++) {  

    5.             System.out.println("播放音乐" + i);  

    6.         }  

    7.     }  

    8. }  

    9.   

    10. //主线程类  

    11. public class ThreadDemo3 {  

    12.     public static void main(String[] args) {  

    13.   

    14.         //启动播放音乐的线程  

    15.         MusicThread thread1 = new MusicThread();  

    16.         thread1.start();  

    17.   

    18.         //主线程  

    19.         for (int i = 0; i < 50; i++) {  

    20.             System.out.println("打游戏" + i);  

    21.         }  

    22.     }  

    23. }  

     

    2、实现Runnable接口,重写run方法,在main函数中,调用start方法。代码如下:

     

    1. //1):定义一个类A实现于java.lang.Runnable接口,注意A类不是线程类.  

    2. class MusicImplements implements Runnable{  

    3.     //2):在A类中覆盖Runnable接口中的run方法.  

    4.     public void run() {  

    5.         //3):在run方法中编写需要执行的操作  

    6.         for(int i = 0; i < 50; i ++){  

    7.             System.out.println("播放音乐"+i);  

    8.         }  

    9.           

    10.     }  

    11. }  

    12.   

    13. public class ImplementsRunnableDemo {  

    14.     public static void main(String[] args) {  

    15.         for(int j = 0; j < 50; j ++){  

    16.             System.out.println("运行游戏"+j);  

    17.             if(j == 10){  

    18.                 //4):在main方法(线程)中,创建线程对象,并启动线程  

    19.                 MusicImplements mi = new MusicImplements();  

    20.                 Thread t = new Thread(mi);  

    21.                 t.start();  

    22.             }  

    23.         }  

    24.     }  

    25.   

    26. }  

    3、实现Callable接口,重写call()方法,在main函数中调用start()方法。

    import java.util.concurrent.Callable;

    public class ThreadImplementsCallable implements Callable<Integer> {

      private int i; 

      @Override

      public Integer call() throws Exception {

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

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

        }

        return i;

      }

    }

     

    import java.util.concurrent.Callable;

    import java.util.concurrent.FutureTask;

    public class Main {

      public static void main(String[] args) {

        Callable<Integer> callable = new ThreadImplementsCallable();

        FutureTask<Integer> futureTask = new FutureTask<>(callable);

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

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

          if (i == 5) {

            new Thread(futureTask).start();

            new Thread(futureTask).start();

          }

        }

        try {

          System.out.println("futureTask ruturn: " + futureTask.get());

        } catch (Exception e) {

          e.printStackTrace();

        }

      }

    }

    展开全文
  • 在前面的帖子中提到了继承Thread类的方法启动线程,但是由于java是单继承的,我们有时需要使用更多类功能以及资源共享,那么实现接口就是个不错的选择,因为Java中我们可以实现多个接口。我们一般通过实现Runnable...

    在前面的帖子中提到了继承Thread类的方法来启动线程,但是由于java是单继承的,我们有时需要使用更多类功能以及资源共享,那么实现接口就是个不错的选择,因为Java中我们可以实现多个接口。我们一般通过实现Runnable接口来创建线程。见下面的例子:
    在这里插入图片描述
    在上面的例子中,我们让TestThread2实现了Runnable接口,并实现了run()方法,与继承Thread类的方式不同的是我们创建了一个Thread类的对象来调用start()方法,因为只有Thread类中有start()方法,Thread对象也叫代理对象。通过阅读API(见下图)我们可以看出,Thread的构造方法中可以传一个Runnable对象,所以我们就把实现了Runnable接口的对象传进Thread构造方法中。
    在这里插入图片描述
    我们以后优先使用实现Runnable接口的方式来创建线程。

    展开全文
  • java多线程之启动线程的三种方式

    万次阅读 多人点赞 2018-08-12 14:42:08
    java对多线程有着良好的支持,java创建和启动线程较为常用的方式有继承Thread类、实现Runnable接口和匿名内部类的方式。 1.继承Thread类: 通过继承Thread类来创建并启动多线程步骤如下: 1、定义Thread类的子类...

    java对多线程有着良好的支持,java创建和启动线程较为常用的方式有继承Thread类、实现Runnable接口和匿名内部类的方式。

    1.继承Thread类:

    通过继承Thread类来创建并启动多线程步骤如下:

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

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

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

    示例代码:

    Thread1类(线程类):

    public class Thread1 extends Thread{
    
    	@Override
    	public void run() {
    		
    		for (int i = 0; i < 50; i++) {
    			System.out.println(Thread.currentThread().getName() + "执行" + i);
    		}
    	}
    }

    Mian类,测试类:

    public class Main {
    	
    	public static void main(String[] args) {
    		new Thread1().start();
    		for (int i = 0; i < 50; i++) {
    			System.out.println(Thread.currentThread().getName() + "执行" + i);
    		}
    	}
    }

    测试结果:

          可以看到main线程和thread0线程的for循环交替执行,线程启动成功。此实例程序中Thread1类继承了Thread类并重写了run方法,在run方法中我们打印出当前执行的线程名称为哪个线程正在执行了,执行了多少次,使用成员变量i来记录执行的次数。在main函数中我们创建了此线程的实例对象,并通过start方法启动了这个个线程,执行时大家可以看到线程是以抢占式的方式运行。虽然只创建了1个线程实例,实际上共有2个线程在运行,还有main方法代表的主线程的线程执行体。

          此外,我们还学习了线程的两个方法:

          1.Thread.currentThread(),是Thread类的静态方法,该方法总是返回当前正在执行的线程对象。

          2.getName():该方法是Thread类的实例方法,该方法返当前正在执行的线程的名称。在默认情况下,主线程的名称为main,用户启动的多线程的名称依次为Thread-0,Thread-1,Thread-3..Thread-n等。

    2.实现Runnable接口:

    实现Runnable接口创建并启动多线程的步骤如下:

    1.定义Runnable接口的实现类,并重写该接口的run方法,该run方法的方法体同样是该线程的线程执行体

    2.创建Runnable实现类的实例对象,并以此实例对象作为Thread的target来创建Thread类,该Thread对象才是真正的线程对象。

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

    示例代码:

    Thread2类(线程类):

    public class Thread2 implements Runnable{
    
    	public void run() {
    		
    		for (int i = 0; i < 50; i++) {
    			System.out.println(Thread.currentThread().getName() + "执行" + i);
    		}
    	}
    
    }

    Mian类:

    public class Main {
    	
    	public static void main(String[] args) {
    		new Thread(new Thread2()).start();
    		for (int i = 0; i < 50; i++) {
    			System.out.println(Thread.currentThread().getName() + "执行" + i);
    		}
    	}
    }

          这里尤其是注意:main函数中名没有直接执行Thread2的run方法,而是将Thread2填入到了Thread中,使用start方法来启动。Runable实现类里包含run方法,仅仅作为线程执行体,而实际的线程对象依然是Thread实例对象,Thread为真正创建线程的对象。

    3.匿名内部类:

          匿名内部类本质上也是一个类实现了Runnable接口,重写了run方法,只不过这个类没有名字,直接作为参数传入Thread类,示例代码:

    Main类:

    public class Main {
    	
    	public static void main(String[] args) {
    		new Thread(new Runnable() {
    			
    			public void run() {
    				for (int i = 0; i < 50; i++) {
    					System.out.println(Thread.currentThread().getName() + "执行" + i);
    				}
    			}
    		}).start();
    		for (int i = 0; i < 50; i++) {
    			System.out.println(Thread.currentThread().getName() + "执行" + i);
    		}
    	}
    }
    

     

    展开全文
  • Java启动线程两种方式总结

    千次阅读 2018-07-12 14:40:48
    先查看jdk帮助文档,这么进行描述线程线程是程序中的执行线程,可以由jvm来运行一个或者多个线程方法1:继承Thread 类 重写run方法即可 如下代码: public class Treadtest { //主方法 public static...

    先查看jdk帮助文档,这么进行描述线程:线程是程序中的执行线程,可以由jvm来运行一个或者多个线程。

     

    方法1:继承Thread 类 重写run方法即可

    如下代码:

     

    public class Treadtest {


    //主方法
    public static void main(String[] args) throws InterruptedException   {

    Thread process = new processTread();
    process.start(); //启动线程 

    }

    }


    class processTread  extends Thread{

    public void  run() {

    Thread.currentThread().setName("子线程1");

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

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

    }

    运行结果如下:

     

    方法2:实现runable接口 重写run方法即可

    同样先看jdk文档

    代码如下:

     

    /*
     * Runable 实现线程方式
     */
    public class RunableTest {


    public static void main(String[] args) {
    // TODO Auto-generated method stub


    DemoTest ra = new DemoTest();

    Thread t = new Thread(ra);

    t.start();
    }

    }


    class DemoTest  implements Runnable{


    @Override
    public void run() {
     
    Thread.currentThread().setName("Runable 实现");
    for (int i = 0; i < 10; i++) {

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

    }


    }

    需要注意的是启动一个线程用start()方法,

    start(); 启动线程后继续执行下面的方法,无需等待run方法体代码执行完毕,直接继续执行下面的代码;

    代码实例:

    运行结果:

    run() 方法只是线程的代码体方法,这里面是需要运行的代码体;

    若调用run()方法,程序中只有main这个线程,该程序只是运行了一个普通的方法(相当于对象调用自己的普通方法而已,并不是真正意义上的多线程。)

    若调用run方法:

    运行结果如下:

    展开全文
  • Java启动线程start和run方法

    千次阅读 2018-07-21 21:31:44
    Java启动线程有两种方法,继承Thread类和实现Runnable接口,由于Java无法实现多重继承,所以一般通过实现Runnable接口来创建线程。但是无论哪种方法都可以通过start()和run()方法启动线程,下面就来介绍一下他们...
  • Java启动线程的三种方式

    千次阅读 2019-10-24 19:02:22
    Thread 继承自Thread。 public class ThreadDemo extends Thread { @Override ... System.out.println(Thread.currentThread().getName() + "-启动了..."); } public static void main(String[] arg...
  • java开启新线程的三种方法方法1:继承Thread类 ...4):在main方法(线程)中,创建一个线程对象并启动线程。 (1)创建线程类对象: A类 a = new A类(); (2)调用线程对象的start方法: a.start();...
  • Java8多线程启动方法

    千次阅读 2017-11-24 21:57:30
    一、进程与线程的区别 总:操作系统执行多任务,每个任务就是进程;进程执行多任务,每个任务就是线程;包含关系 分: 1.调度性:在引入线程的OS中,把线程作为调度和分派的基本单位,把进程作为资源拥有的基本...
  • 先说结论:main方法启动后,jvm会开启多个守护线程,但main方法中的代码是被单线程执行的。 上代码: 下面这段代码通过java提供的线程管理类ThreadMXBean中的dumpAllThreads方法返回所有活动线程线程信息,并打印...
  • Java线程的实现方式详解(Java基础)

    千次阅读 多人点赞 2020-05-29 18:15:48
    你好我是辰兮,很高兴你能来阅读,本篇为Java基础之多线程的实现讲解,基础知识的讲解,相关的更多,面试知识已经提前整理好文章可以阅读学习,希望对初学者有帮助。 线程进程基础知识参考: 进程线程的面试问题小...
  • public class MyTest { public static void main(String[] args) ... System.out.println("main方法调用method,得到了结果"+result+":"+new Date().toLocaleString()); } public static String method(){ .
  • 详情请见======&gt;转自:https://blog.csdn.net/it_beecoder/article/details/78446747
  • Java线程超详解

    万次阅读 多人点赞 2019-06-11 01:00:30
    引言 随着计算机的配置越来越高,我们需要将进程进一步优化,细分为线程,充分提高图形化界面的多线程的开发。这就要求对线程的掌握很...启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
  • run方法运行结果 run()方法只是类的一个普通方法,如果直接调用run()方法...用start方法启动线程,真正实现了多线程运行,这时无需等待run方法体中的代码执行完毕而直接继续执行后续的代码。通过调用Thread类的...
  • 启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM调度并执行,这并不意味着线程就会立即运行。run()方法线程启动后要进行回调(callback)的方法。 ...
  • Java线程wait()方法注意事项

    千次阅读 2019-05-02 11:40:38
    注意事项一: 当前线程调用共享对象的wait()方法时,当前线程只会释放当前共享对象的锁,当前线程持有的其他共享对象的监视器锁并不会被释放。 下面举个栗子: private static volatile Object resourceA = new ...
  • java线程 isAlive方法的有趣现象

    千次阅读 2018-01-29 17:20:34
    线程中的isAlive方法相信大家都知道。无非就是当前线程如果是存活的,在运行中,则返回true,否则返回false,不过还是有些有趣现象的,我们这里用代码演示一下:class TestThread extends Thread{ @Override public...
  • JAVA线程实现的四种方式

    千次阅读 2018-06-19 18:44:40
    Java线程实现方式主要有四种:继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。   其中前两种方式...
  • java同时启动多个线程(一)

    千次阅读 2019-03-11 14:59:51
    当我们需要同时启动N个线程时, 可以使用java.util.concurrent.CyclicBarrier 类解决。 demo: import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; public class...
  • Java中怎么创建一个线程。1、继承Thread类并重写run()方法public class MyThread extends Thread{ public void run(){ //此处为线程工作代码 } }2、实现Runnable接口并实现接口中的run()方法public class ...
  • Java线程(超详细)

    千次阅读 2021-01-12 21:14:38
    =》 分别怎么启动线程? =》 多线程带来了数据安全问题,该怎么解决? =》 怎么使用synchronized(同步)决解? =》使用同步可能会产生死锁,该怎么决解? =》 线程之间是如何通信的? =》 线程有返回值吗?该如何...
  • Java线程面试题(面试必备)

    万次阅读 多人点赞 2020-05-26 01:15:38
    2. 线程与进程2.1 什么是线程与进程2.2 线程与进程的区别2.3 用户线程与守护线程2.4 什么是线程死锁2.5 形成死锁的四个必要条件2.6 如何避免死锁3. 创建线程的四种方式4. 线程状态和基本操作 一、多线程基础基础...
  • java之内部类中启动线程

    千次阅读 2017-12-22 09:28:29
    1 java拥有一个内部类机制。 如:public class TestNeibuleiThread { class ThreadClass1{ public void save(final List lists){ for(int i=0;i System.out.println("neibulei:"+i+","+lists.get(i)+","+...
  • Java中终止线程的三种方法

    千次阅读 2021-02-26 20:57:55
    终止线程一般建议采用的方法是让线程自行结束,进入Dead(死亡)状态,就是执行完run()方法。即如果想要停止一个线程的执行,就要提供某种方式让线程能够自动结束run()方法的执行。比如设置一个标志来控制循环是否执行...
  • java线程实现的四种方式

    千次阅读 2018-08-29 11:13:07
    一个线程的生命周期 线程是一个动态执行的过程,它也有一个从产生到死亡的过程。 下图显示了一个线程完整的生命... 当线程对象调用了start()方法之后,该线程就进入就绪状态。就绪状态的线程处于就绪队列中,要...
  • Java线程常用方法

    千次阅读 多人点赞 2019-10-21 19:14:13
    start() 启动线程并执行相应的run()方法 run() 子线程要执行的代码放入run()方法 getName()和setName() getName() 获取此线程的名字 setName() 设置此线程的名字 isAlive() 是判断当前线程是否处于活动状态。...
  • java开启子线程方法及优化

    千次阅读 2018-08-22 14:54:09
    相比new Thread,Java提供的四种线程池的好处在于: a. 重用存在的线程,减少对象创建、消亡的开销,性能佳。 b. 可有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。 c. 提供...
  • Java创建并执行线程的四种方法

    万次阅读 多人点赞 2017-10-04 23:00:14
    java里面创建线程有四种方式: 无返回: 1. 实现Runnable接口,重写run(); 2. 继承Thread类,重写run(); 有返回: 1. 实现Callable接口,重写call(),利用FutureTask包装Callable,并作为task传入Thread构造函数...
  • Java中停止线程执行的方法

    万次阅读 2015-06-27 15:51:29
    Java中停止线程执行的方法作者:chszs,转载需注明。博客主页:http://blog.csdn.net/chszs一、暂停或停止线程的理论在Java编程中,要暂停或停止当前正在运行的线程,有几种方法。对于把线程转入睡眠Sleep状态,使用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 583,069
精华内容 233,227
关键字:

java启动线程的方法

java 订阅