精华内容
下载资源
问答
  • JAVA创建线程的三种方式继承Thread创建线程实现Runnable接口创建线程类通过Callable和Future创建线程 继承Thread创建线程 public class ThreadDemo extends Thread{ //重写Thread的run()方法 public void run() {...

    继承Thread创建线程

    public class ThreadDemo extends Thread{
    
        //重写Thread的run()方法
        public void run() {
            //线程会执行的指令
            //TODO
            System.out.println("Thread execute");
        }
    
        public static void main(String[] args) {
            ThreadDemo demo = new ThreadDemo();
            demo.start();
            System.out.println("Main execute");
        }
    }
    
    
    输出结果
    Main execute
    Thread execute
    
    1. 编写业务类继承Thread类并重写Thread类的run()方法,在run()方法中实现我们的业务逻辑。因此把run()方法称为执行体。
    2. 创建业务类的实例对象
    3. 因为业务类继承了Thread类,所以使用业务类的对象就可以调用start()来启动线程

    实现Runnable接口创建线程类

    public class RunnableThreadDemo implements Runnable {
        //实现Runnable的run()方法
        public void run() {
            //线程会执行的指令
            //TODO
            System.out.println("Runnable execute");
        }
    
        public static void main(String[] args) {
            ThreadDemo demo = new ThreadDemo();
            demo.start();
            System.out.println("Main execute");
        }
    }
    
    输出结果
    Main execute
    Thread execute
    
    1. 编写业务类实现Runnable接口并重写Runnable的run()方法,在run()方法中实现我们的业务逻辑。
    2. 创建业务类的实例对象
    3. 因为业务类实现Runnable接口,所以使用业务类的对象就可以调用start()来启动线程

    通过Callable和Future创建线程

    public class CallableThreadDemo implements Callable<String> {
        @Override
        public String call() throws Exception {
            //线程会执行的指令。类似于Thread和Runnable的run()方法
            System.out.println("Callable execute");
            return "SUCCESS";
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            CallableThreadDemo demo = new CallableThreadDemo();
            FutureTask<String> ft = new FutureTask<>(demo);
            new Thread(ft).start();
            System.out.println(ft.get());
            System.out.println("Main execute");
        }
    }
    输出结果
    Callable execute
    SUCCESS
    Main execute
    
    1. 创建业务类实现Callable接口并实现接口的call()方法,call()方法和run()方法类似,不同的是call()是带有返回值,其返回值的类型由Callable接口的泛型决定
    2. 创建业务类的实例,使用FutureTask类来包装Callable对象,FutureTask对象封装了该Callable对象的call()方法的返回值。
    3. 使用FutureTask对象作为Thread对象的target创建并启动新线程。
    4. 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

    本文仅个人学习整理,有不足之处,欢迎大家指点

    展开全文
  • Java创建线程的三种方式 1、继承Thread类 此方式创建多线程简单易懂,但是同时代码量也大大增加。 每个线程或许只进行一个操作也需要创建一个新的类去继承Thread类,且只能继承Thread类。 获取线程简单,直接使用...

    Java创建线程的三种方式

    1、继承Thread类

    此方式创建多线程简单易懂,但是同时代码量也大大增加。
    每个线程或许只进行一个操作也需要创建一个新的类去继承Thread类,且只能继承Thread类。
    获取线程简单,直接使用this即可
    不能在run方法中抛出异常

    // 继承Thread类创建线程:线程只能单继承,每个不同的操作都要一个新的类
    public class ThreadTest extends Thread {
    
        public ThreadTest(String name) {
            super(name);
        }
    
        static int i = 0;
    
        @Override
        public void run() {
            for (; i < 100; i++) {
                System.out.println("线程名称:" + this.getName() + "index:" + i);
                try {
                    Thread.sleep(30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) {
    
            Thread thread = new ThreadTest("1 - ");
            Thread thread2 = new ThreadTest("2 - ");
            thread2.start();
            thread.start();
    
        }
    
    }
    

    2、实现Runnable接口

    线程可以继承其他的类,且jdk8之后可以不用创建新的类就可实现多线程,编写简单,大大减少代码量。个人比较倾向于此方式创建线程
    访问当前线程较麻烦:Thread.currentThread()
    不能在run方法中抛出异常

    // Runnable创建多线程特点:可以多实现,减少代码量
    public class RunnableTest implements Runnable {
    
        static int index = 0;
    
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("线程名称:" + Thread.currentThread().getName() + "index: " + index);
                index++;
            }
        }
    
        public static void main(String[] args) {
    
            Thread thread = new Thread(new RunnableTest(), "1 - >>> ");
            Thread thread2 = new Thread(new RunnableTest(), "2 - >>> ");
            // jdk1.8后实现Runnable接口创建线程的写法
            Thread thread3 = new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    System.out.println("线程名称:" + Thread.currentThread().getName() + "index: " + index);
                    index++;
                }
            }, "3 - >>>");
    
            thread3.start();
            thread.start();
            thread2.start();
        }
    }
    

    3、实现Callable接口

    这种方式最大的特点就是可以获取到线程执行完成后的返回值
    可以在call方法中抛出异常,这也是以上两种方式不能实现的
    也可以继承其他父类,获取线程也比较繁琐,和runnable方式一样

    /**
     * 实现callable创建多线程特点:
     *      可以有返回值,可以在call方法中抛出异常
     */
    public class CallableTest implements Callable<String> {
    
        static int index = 0;
    
        @Override
        public String call() throws Exception {
            for (int i = 0; i < 10; i++){
                System.out.println("当前线程:" + Thread.currentThread().getName() + " --- " + index );
                index--;
            }
            return Thread.currentThread().getName() + "index: " + index;
        }
    
        public static void main(String[] args) {
    
            CallableTest callableTest = new CallableTest();
            FutureTask<String> futureTask = new FutureTask<>(callableTest);
    
            FutureTask<String> future = new FutureTask<>(callableTest);
            // 每次传入Thread的future不能是同一个,如果传入同一个future的话并不能实现多线程
            // 但是可以两个future对象中的参数可以是同一个callable的的对象,也可以实现多线程
            new Thread(futureTask, "1 - ").start();
            new Thread(future, "2 - ").start();
    
            try {
                System.out.println(future.get());
                System.out.println(futureTask.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
    
        }
    }
    

    以上内容均属个人练习与理解,仅供参考

    展开全文
  • Java 创建线程的三种方式分别是:继承Thread类、实现Runnable接口和实现Callable接口; 1.继承Thread类示例 public class StartThread extends Thread{ @Override public void run() { System.out.println(...

     

    Java 创建线程的三种方式分别是:继承Thread类、实现Runnable接口和实现Callable接口;

    1.继承Thread类示例

    public class StartThread extends Thread{
        @Override
        public void run() {
            System.out.println("thread线程创建");
            System.out.println("thread --> "+Thread.currentThread().getName());
        }
    
        public static void main(String[] args) {
            StartThread st=new StartThread();
            st.start();
            System.out.println("main --> "+Thread.currentThread().getName());
        }
    }

    2.实现Runnable接口示例

    public class StartRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("thread线程创建");
            System.out.println("thread --> "+Thread.currentThread().getName());
        }
    
        public static void main(String[] args) {
            StartRunnable sr=new StartRunnable();
            Thread t=new Thread(sr,"zaza");
            t.start();
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("main --> "+Thread.currentThread().getName());
        }
    
    }

    3.实现Callable接口示例

    public class StartCallable implements Callable {
    
        @Override
        public Object call() throws Exception {
            System.out.println("thread --> "+Thread.currentThread().getName());
            return null;
        }
    
        public static void main(String[] args) {
            StartCallable sc=new StartCallable();
            ExecutorService executorService= Executors.newFixedThreadPool(2);
            Future future1=executorService.submit(sc);
            Future future2=executorService.submit(sc);
            System.out.println(future2.isDone());
            System.out.println("main --> "+Thread.currentThread().getName());
            executorService.shutdown();
        }
    }

    三种方式对比

    1.继承Thread类的方式实现比较简单,但是受限于单继承;

    2.实现Runnable、Callable接口比较灵活,不受限于单继承,适合多个线程进行资源共享,同时增强了程序的扩展性,降低了程序的耦合性;实现类中,运行Callable任务可以拿到一个Future对象,通过Future对象可以了解任务执行情况;

    Runnable类:

    @FunctionalInterface
    public interface Runnable {
        /**
         * When an object implementing interface <code>Runnable</code> is used
         * to create a thread, starting the thread causes the object's
         * <code>run</code> method to be called in that separately executing
         * thread.
         * <p>
         * The general contract of the method <code>run</code> is that it may
         * take any action whatsoever.
         *
         * @see     java.lang.Thread#run()
         */
        public abstract void run();
    }

     Callable类

    @FunctionalInterface
    public interface Callable<V> {
        /**
         * Computes a result, or throws an exception if unable to do so.
         *
         * @return computed result
         * @throws Exception if unable to compute a result
         */
        V call() throws Exception;
    }

     

     

     


    ————————————————
    版权声明:本文为CSDN博主「longshengguoji」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/longshengguoji/article/details/41126119

     

    展开全文
  • 创建线程的三种方式的对比 Java 提供了三种创建线程的方法: 通过继承 Thread 类本身; 通过实现 Runnable 接口; 通过 Callable 和 Future 创建线程。 一、通过继承 Thread 类本身; 定义子类继承Thread类。 ...

    在这里插入图片描述

    Java 提供了三种创建线程的方法:

    1. 通过继承 Thread 类本身;
    2. 通过实现 Runnable 接口;
    3. 通过 Callable 和 Future 创建线程。

    一、通过继承 Thread 类本身;

    1. 定义子类继承Thread类。
    2. 子类中重写Thread类中的run方法。
    3. 创建Thread子类对象,即创建了线程对象。
    4. 调用线程对象start方法:启动线程,调用run方法。
    //方式1
    package thread.Test1;
     
    public class Demo1 extends Thread{
    	
        //重写的是父类Thread的run()
    	public void run() {
    		System.out.println(getName()+"is running...");
    	}
    	
    	
    	public static void main(String[] args) {
    		Demo1 demo1 = new Demo1();
    		Demo1 demo2 = new Demo1();
    		demo1.start();
    		demo2.start();
    	}
    }
    

    二、通过实现 Runnable 接口;

    1. 定义子类,实现Runnable接口。
    2. 子类中重写Runnable接口中的run方法。
    3. 通过Thread类含参构造器创建线程对象。
    4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
    5. 调用Thread类的start方法:开启线程,调用Runnable子类接口的run方法。
    public class ImpRunnable implements Runnable {
    	
    	private int i;
    	
    	@Override
    	public  void run() {
    		for(;i < 50;i++) {	
    			//当线程类实现Runnable接口时,要获取当前线程对象只有通过Thread.currentThread()获取
    			System.out.println(Thread.currentThread().getName() + " " + i);
    		}
    	}
     
    	public static void main(String[] args) {
    		for(int j = 0;j < 30;j++) {
    			System.out.println(Thread.currentThread().getName() + " " + j);
    			if(j == 10) {
    				ImpRunnable thread_target = new ImpRunnable();
    				//通过new Thread(target,name)的方式创建线程
    				new Thread(thread_target,"线程1").start();
    				new Thread(thread_target,"线程2").start();
    			}
    			
    		}
     
    	}
     
    }
    

    注意点:

    1. 如果自己手动调用run()方法,那么就只是普通方法,没有启动多线程模式。
    2. run()方法由JVM调用,什么时候调用,执行的过程控制都有操作系统的CPU调度决定。
    3. 想要启动多线程,必须调用start方法。
    4. 一个线程对象只能调用一次start()方法启动,如果重复调用了,则将抛出以上
      的异常“IllegalThreadStateException”。


      执行流程图:在这里插入图片描述

    三、通过 Callable 和 Future 创建线程。

    1. 创建 Callable 接口的实现类,并实现 call() 方法,该 call() 方法将作为线程执行体,并且有返回值。

    2. 创建 Callable 实现类的实例,使用 FutureTask 类来包装 Callable 对象,该FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。

    3. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。

    4. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

    public class CallableThreadTest implements Callable<Integer> {
        public static void main(String[] args)  
        {  
            CallableThreadTest ctt = new CallableThreadTest();  
            FutureTask<Integer> ft = new FutureTask<>(ctt);  
            for(int i = 0;i < 100;i++)  
            {  
                System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
                if(i==20)  
                {  
                    new Thread(ft,"有返回值的线程").start();  
                }  
            }  
            try  
            {  
                System.out.println("子线程的返回值:"+ft.get());  
            } catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            } catch (ExecutionException e)  
            {  
                e.printStackTrace();  
            }  
      
        }
        @Override  
        public Integer call() throws Exception  
        {  
            int i = 0;  
            for(;i<100;i++)  
            {  
                System.out.println(Thread.currentThread().getName()+" "+i);  
            }  
            return i;  
        }  
    }
    

    创建线程的三种方式的对比

    1. 采用实现 Runnable、Callable 接口的方式创建多线程时,线程类只是实现了 Runnable 接口或 Callable 接口,还可以继承其他类。

    2. 使用继承 Thread 类的方式创建多线程时,编写简单,如果需要访问当前线程,则无需使用 Thread.currentThread() 方法,直接使用 this 即可获得当前线程。

    展开全文
  • java创建线程三种方式: 1:实现Runnable接口(无返回值) 2:继承Thread类(无返回值) 3:使用ExecutorService、Callable、Future(有返回值) 实现Runnable接口 java 依靠接口来实现多态,所以在实现了Runnable...
  • java 创建线程的三种方式、创建线程池的四种方式

    万次阅读 多人点赞 2019-02-23 21:01:44
    java创建线程的三种方式: 继承Thread类创建线程类 实现Runnable接口 通过Callable和Future创建线程 java创建线程池的四种方式: newCachedThreadPool 创建一个可缓存的线程池,如果线程池长度超过处理...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,473
精华内容 989
关键字:

java创建线程的三种方式

java 订阅