精华内容
下载资源
问答
  • 线程2 Java多线程实现2.1 继承Thread类实现多线程2.2 实现Runnable接口来实现多线程2.3 继承Thread类与实现Runnable借口的区别 1 进程与线程 1.1 进程与线程的概念 什么是进程?   进程: 操作系统中一个程序的...

    1 进程与线程

    1.1 进程与线程的概念

      Java是第一门原生支持多线程的高级语言
    什么是进程?
      进程: 在一个操作系统中,每个独立执行的程序都可称之为一个进程,也就是“正在运行的程序”。Windows操作系统下,鼠标右键单击任务栏,选择【启动任务管理器】选项可以打开任务管理器面板,在窗口的【进程】选项卡中可以看到当前正在运行的程序,也就是系统所有的进程。

    在这里插入图片描述
      多进程: 同一时刻跑多个(进程)程序。比如我们在用腾讯视频看电视的时候照样可以登录qq和朋友聊天
      在DOS(磁盘操作系统时代),由于其本身就是一个单进程的操作系统,所以在同一时间段上只能够有一个程序执行;后来发展到Windows系统后,我们可以发现多个程序可以同时执行,所以Window是一个多进程的操作系统。现在基本上所有的操作系统都是多进程。
    什么是多线程?
      一个程序(进程)可以执行多个任务,通常,每一个任务就称之为一个线程。登录qq和朋友聊天,此时肯定存在读线程和写线程同时运行。

    1.2 对比进程、线程

    • 与进程相比,线程更加的轻量级,创建、撤销一个线程比启动、撤销一个进程开销要小的多,并且一个进程中的所有线程共享此程序(进程)的所有资源。
    • 没有进程就没有线程,进程一旦终止,其内的线程也将不复存在。就像你登录QQ和朋友聊天,如果某一时刻你关掉了QQ,读线程和写线程也将不复存在
    • 进程是操作系统资源调度的基本单位,进程可以独享资源;线程需要依托进程提供的资源,无法独立申请操作系统资源,是操作系统任务执行的基本单位。
      多进程与多线程的区别?
        本质区别在于,每个进程拥有自己的一整套变量,而线程则共享数据,共享变量使得线程之间的通信比进程之间的通信更加有效方便。

    1.3 高并发

      高并发指的是:同一时刻线程的访问量非常高
      高并发带来的问题:服务器内存不够用,无法处理新的请求
    在这里插入图片描述

    1.4 线程的状态

    在这里插入图片描述

    2 Java的多线程实现

    2.1 继承Thread类实现多线程

      java.lang.Thread是一个线程操作的核心类,(java.lang包会自动导入,所以不需要手动书写)新建一个线程最简单的方式就是直接继承Thread类,而后覆写该类中的run()方法。(就相当于主线程的main方法,每个线程都应该有一个入口,主方法是主线程的入口,run方法是线程入口
    继承Thread定义线程

    class MyThread extends Thread{
        private String title;
        public myThread(String title) {
            this.title = title;
        }
        @Override
        public void run()  //所有线程从此处开始运行
        {
            for(int i=0;i<10;i++)
            {
                System.out.println(this.title+" i="+i);
            }
        }
    }
    

      新建一个线程最简单的方式就是继承Thread类,而后覆写该类中的run()方法,很自然我们就想到产生线程类的实例化对象而后调用run()方法。
    在这里插入图片描述
      显然,这个时候只做了顺序打印,和多线程一点关系都没有(多线程的意思是任务同时进行所有不可能顺序打印)可见启动多线程的方式错误。
    启动多线程public synchronized void start() 此方法会自动调用线程的run()方法
    在这里插入图片描述
      无论哪种方式实现多线程,线程启动一定调用Thread类的start()方法,而不是直接对象名.run()
    看start()的源码:
    在这里插入图片描述

    1. 首先我们看到在start()方法中抛出IllegalThreadStateException线程状态异常,按照原有处理方式,应当在调用处进行异常处理,然而此处没有处理也不会报错,因此是一个RunTimeException(非受查异常),这个异常的产生只是因为你重复启动了线程才会产生,所以每一个线程对象只能够启动一次
      在这里插入图片描述
    2. 我们看到在start()方法中调用了start0()方法,而这个方法是一个只声明而未实现的方法,同时使用native关键字进行定义。private native void start0();
      native指的是调用本机的原生系统函数:(方法体在C语言中实现)
      Thread类有个 registerNatives 本地方法,该方法主要的作用就是注册一些本地方法供 Thread 类使用,如 start0(),stop0() 等等,可以说,所有操作本地线程的本地方法都是由它注册的。
      这个方法放在一个 static 语句块中,当该类被加载到 JVM 中的时候,它就会被调用,进而注册相应的本地方法。而本地方法 registerNatives 是定义在 Thread.c 文件中的。
      在这里插入图片描述
      Thread.c 是个很小的文件,它定义了各个操作系统平台都要用到的关于线程的公用数据和操作,如下:
      在这里插入图片描述
        观察上边一小段代码,可以容易的看出 Java 线程调用 start->start0 的方法,实际上会调用到 JVM_StartThread 方法,那这个方法又是怎么处理的呢?
      在这里插入图片描述
        综上可知,Java线程创建的调用流程为::调用Thread类的start()(Java方法)方法,判断线程是不是新创建的,如果不是新创建的抛出IllegalThreadStateException异常线程状态,如果是新创建的调用start0()(JVM)方法,JVM进行资源调度,系统分配,准备好了之后回调run()(Java方法)方法,执行线程的具体操作任务。

    问题:为什么要通过start()方法来调用run()方法,而不是直接run()执行?

      run的特殊性只是在于调用者是谁,如果用户直接调用run方法,run方法无任何特殊之处,它就是个普通方法,但是若是JVM回调的,这个时候已经有线程,把run方法交给线程执行。

    2.2 实现Runnable接口来实现多线程

    继承Thread类已经可以实现多线程了,为什么还要有接口?
      如果一个类为了实现多线程直接去继承Thread类就会有单继承局限,在也无法继承其它的类实现其他功能,所以在Java中又提供有另外一种实现模式:Runnable接口
    在这里插入图片描述
    实现Runnable定义线程

    class myThread implements Runnable{
        private String title;
        public myThread(String title) {
            this.title = title;
        }
        @Override
        public void run()  //所有线程从此处开始运行
        {
            for(int i=0;i<10;i++)
            {
                System.out.println(this.title+" i="+i);
            }
        }
    }
    

      此时的myThread类继承的不在是Thread类而是实现了Runnable接口,虽然解决了单继承局限问题,但是没有start()方法了,线程无法启动。
      那么此时就需要关注Thread类提供的构造方法。
    Thread类提供的构造方法:public Thread(Runnable target)可以接受Runnable接口对象。
    在这里插入图片描述
    对于此时的Runnable接口对象可以采用匿名内部类或者Lambda表达式来定义

    范例:使用匿名内部类进行Runnable对象创建

    package  www.miao.java;
    public class Test{
        public static void main(String [] args){
            //匿名内部类
            new Thread ( new Runnable(){
                @Override
                public void run() {
                    System.out.println("Hello World!!!");
                }
            } ).start();
        }
     }
    

    范例:使用Lamdba表达式进行Runnable对象创建

    package  www.miao.java;
    public class Test{
        public static void main(String [] args){
            Runnable runnable = ()-> System.out.println("Hello World!!");
            new Thread(runnable).start();
        }
     }
    

    在实际开发之中,大多采用的是以上两种操作来进行Runnable对象创建。

    2.3 继承Thread类与实现Runnable接口的区别

    • 从使用形式上讲,明显使用Runnable实现多线程要比继承Thread类好,因为可以避免单继承局限。
    • Thread类的声明:public class Thread implements Runnable
      Thread类是Runnable接口的子类,那么Thread类一定覆写了Runnable接口的run()方法。
    @Override
    public void run() {
    	private Runnable target;
    	//target是Runnable接口,此时若传进来一个Runnable接口,执行传进来接口的run方法
    	if (target != null) {
    		target.run();		
    	}
    }
    
    public Thread(Runnable target) {
    	init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    
    • Thread与自定义的线程类(实现了Runnable接口)是一个典型的代理模式,Thread类负责辅助真实业务操作(资源调度、线程的创建并启动),自定义线程类主要负责真实业务的实现。典型的代理模式
    • 使用Runnable接口实现的多线程程序类可以更好的描述共享的概念
      例如:使用Thread实现数据共享
    package  www.miao.java;
    class MyThread extends  Thread{
        private int ticket = 10;
        private String title;
        public MyThread( String title) {
            this.title = title;
        }
    
        @Override
        public void run() {
            while(this.ticket>0)
            {
                System.out.println(this.title +"剩下"+this.ticket--+"票!");
            }
        }
    }
    public class Test{
        public static void main(String [] args){
           MyThread thread1 = new MyThread("12306");
           MyThread thread2 = new MyThread("携程");
           MyThread thread3 = new MyThread("火车站");
           thread1.start();
           thread2.start();
           thread3.start();
        }
     }
    

    在这里插入图片描述
      此时启动三个线程实现卖票处理,结果变为了卖各自的票。即12306、携程、火车站各有十张票,但是实际生活中却应该是12306、携程、火车站柜台它们一起卖这十张票.
    例如:使用Runnable接口实现数据共享

    package  www.miao.java;
    class MyThread implements  Runnable{
        private int ticket = 10;
    
        @Override
        public void run() {
            while(this.ticket>0)
            {
                System.out.println("剩下"+this.ticket--+"票!");
            }
        }
    }
    public class Test{
        public static void main(String [] args){
           MyThread thread1 = new MyThread();
           //多个线程共同享用同一个Runnable对象
           new Thread(thread1).start();
           new Thread(thread1).start();
        }
     }
    

    在这里插入图片描述

    2.4 实现Callable接口实现多线程

      从JDK1.5开始追加了新的开发包,java.uti.concurrent这个开发包主要是进行高并发编程使用的,包含很多在高并发操作中会使用的类,在这个包里定义有一个新的接口Callable。
    在这里插入图片描述
      Runnable中的run()方法没有返回值,线程一开始就不回头,但是很多时候需要一些返回值,例如某些线程执行完成后可能带来一些返回结果,这种情况下只能利用Callable来实现多线程。
    实现Callable接口定义线程:

    class MyThread implements Callable<String>
    {
        private int ticket =10;
    
        @Override
        public String call() {
            while (this.ticket > 0) {
                System.out.println("剩余票数:" + this.ticket--);
            }
            return "票卖完了,下次吧!";
        }
    }
    

      此时的线程不仅没有单继承局限,还有返回值,但是没有Thread类的start()方法,线程无法启动。
    在这里插入图片描述
      Future接口:V get() throws InterruptedException,ExecutionException
    取得Callable接口的返回值,两个搭配使用。
      RunnableFuture接口实现了Runnable接口Future接口,FutureTask类实现了RunnableFuture接口,所以FutureTask覆写了RunnableFuture接口的所有方法,包括Runnable接口中的Run()方法,以及Future中的get()方法。
      FutureTask中有构造方法可以接收Callable对象。
      启动线程:

    package  www.miao.java;
    import java.util.concurrent.*;
    class MyThread implements Callable<String>
    {
        private int ticket =10;
    
        @Override
        public String call(){
            while (this.ticket > 0) {
                System.out.println("剩余票数:" + this.ticket--);
            }
            return "票卖完了,下次吧!";
        }
    }
    
    public class Test{
        public static void main(String [] args)throws InterruptedException,ExecutionException{
            FutureTask<String> task = new FutureTask<>(new MyThread());
            new Thread(task).start();
            new Thread(task).start();
            System.out.println(task.get());
        }
     }
    

    在这里插入图片描述

    展开全文
  • 详述Java实现Callable接口实现多线程的方式

    万次阅读 多人点赞 2018-07-30 14:59:19
    在这里把最近学习的实现Callable接口实现多线程的方式做一个总结: 首先我们都知道,在Java中最常见的是继承Thread类和实现Runnable接口来实现多线程( 这里我推荐采用实现接口的方式来实现多线程,原因有两点: ...

    公司项目忙的晕头转向,终于有时间可以看点自己想看的东西了。在这里把最近学习的实现Callable接口实现多线程的方式做一个总结:

    首先我们都知道,在Java中最常见的是继承Thread类和实现Runnable接口来实现多线程(

    这里我推荐采用实现接口的方式来实现多线程,原因有两点:

    1、Java的设计是单继承的设计,如果采用继承Thread的方式实现多线程,则不能继承其他的类。

    2、采用接口能够更好的实现数据共享。线程的启动需要Thread类的start方法,如果采用继承的方式每次新建一个线程时,每个新建线程的数据都会单独的存在线程内存中,这样每个线程会单独的操作自己线程的数据,不能更好的实现线程之间的数据共享)

    但是无论以上哪种方式实现多线程,都存在一个问题,就是线程run方法没有返回值,如果一个线程需要有返回值时,可以采用本章讲的实现Callable接口来实现多线程

    首先看一下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;
    }

    首先明确一点这是一个函数式接口,其中的@FunctionalInterface定义了这个接口为函数式接口(具体函数式接口和普通接口有何区别可以自行查阅相关资料) ,Callable接口接受一个泛型作为接口中call方法的返回值类型,因此我们在使用时需要传入一个返回值类型。

    然后我去实现这个接口来定义我自己的线程类,这里我传入了一个String类型作为接口call方法的返回值类型,然后实现了call方法,将result作为返回结果返回

    public class MyCallable<String> implements Callable<String> {
    
    	private int tickt=10;
    	
    	@Override
    	public String call() throws Exception {
    		// TODO Auto-generated method stub
    		String result;
    		while(tickt>0) {
    			System.out.println("票还剩余:"+tickt);
    			tickt--;
    		}
    		result=(String) "票已卖光";
    		return result;
    	}
    
    }

    采用实现Callable接口实现多线程启动方式和以往两种的方式不太一样,下面就看一下怎样启动采用实现Callable接口的线程,首先我 new 一个我的实现实例,然后将我生成的实例对象注册进入到

    FutureTask类中,然后将FutureTask类的实例注册进入Thread中运行。最后可以采用FutureTask<V>中的get方法获取自定义线程的返回值

    	public static void main(String[] args) throws InterruptedException, ExecutionException {		
    		MyCallable<String> mc=new MyCallable<String>();
    		FutureTask<String> ft=new FutureTask<String>(mc);
    		new Thread(ft).start();
    		String result=ft.get();
    		System.out.println(result);
    	}
    	

    最后我解释一下为什么实现Callable接口实现的多线程的形式需要采用这样的方式去启动线程。上面我们已经看了Callable接口的源码,其中只有一个call方法的定义,下面我们看一下FutureTask<V>类的定义,其中我们可以看到FutureTask<V>类是实现了RunnableFuture<V>接口的,我们再看FutureTask<V>类其中 的一个构造方法如下,其中需要传入一个Callable<V>类型的参数,更多内容可以自行查看FutureTask<V>类的具体实现,这里我们只需要知道此构造方法传入一个Callable<V>类型的参数,然后赋值给FutureTask<V>中的私有属性

    public class FutureTask<V> implements RunnableFuture<V>{ 
    
    
     public FutureTask(Callable<V> callable) {
            if (callable == null)
                throw new NullPointerException();
            this.callable = callable;
            this.state = NEW;       // ensure visibility of callable
        }
    }

    然后我们再看 RunnableFuture<V>  接口,这个接口我们可以看到继承了Runnable, Future<V> 两个接口

    public interface RunnableFuture<V> extends Runnable, Future<V> {
        /**
         * Sets this Future to the result of its computation
         * unless it has been cancelled.
         */
        void run();
    }

    最后就是我们Thread类,无论我们以怎样的形式实现多线程,都需要调用Thread类中的start方法去向操作系统请求io,cup等资源,在Tread中有一个构造方法是传入一个Runnable接口类型的参数,而我们上面的FutureTask<V>实例实现了 RunnableFuture<V> 接口,而 RunnableFuture<V> 接口又继承了Runnable接口和 Funture<V>接口,因此我们可以将FutureTask<V> 的一个实例当做是一个Runnable接口的实例传入Thread来启动我们新建的线程

    下面是我画的各个类之间的关系图

     

    展开全文
  • 使用Callable接口实现多线程 在Runnable接口实现多线程会出现Runnable接口中的run()方法不能返回操作结果的问题,Callable接口即是用来解决在这个问题 接口的定义: publlic interface Callable<V>{ public...

    使用Callable接口实现多线程

    在Runnable接口实现的多线程会出现Runnable接口中的run()方法不能返回操作结果的问题,Callable接口即是用来解决在这个问题

    接口的定义:

    publlic interface Callable<V>{
        public V call() throws Exception;
    }
    

    call()方法返回的类型由Calable接口上的泛型类型动态决定。

    由于Thread类中并没有定义任何构造方法可以直接接收Callable接口对象实例,并且由于需要接收call()方法返回值的问题,所以从JDK1.5开始提供有一个java.until.concurrent.FutureTask类。

    此类定义:

    public class FutureTask<V> extends Object
    implements RunnableFuture<V>
    

    其中RunnableFuture接口实现了Future与Runnable接口

    表 FutureTask类的常用方法:

    方法类型描述
    public FetureTask(Callable callable)构造接收Callable接口实例
    public FutureTask(Runnable runnable,V result)构造接收Runnable实例,并指定返回结果类型
    public V get() throws InterruptedException,ExecutionException普通取得线程操作结果,此方法为Future接口定义

    通过FutureTask类的继承结构可以发现其为Runnable接口的子类,并且FutureTask类可以接收Callable接口实例,这样依然可以利用Thread类来实现多线程的启动,而如果想要接收返回结果,则利用Future接口中的get()方法即可。

    例、

    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    class MyThread implements Callable<String>{
        private int ticket=5;
        public String call() throws Exception{
            for(int x=0;x<100;x++){
                if(this.ticket>0){
                    System.out.println("卖票,ticket="+this.ticket--);
                }
            }
            return "票已卖光!";
        }
    }
    
    public class Demo{
        public static void main(String[] args){
            MyThread mt1=new MyThread();
            MyThread mt2=new MyThread();
            FutureTask<String> task1=new FutureTask<String>(mt1);
            FutureTask<String> task2=new FutureTask<String>(mt2);
            new Thread(task1).start();
            new Thread(task2).start();
            try {
    			System.out.println("A线程返回结果:"+task1.get());
                System.out.println("B线程返回结果:"+task2.get());
    		} catch (InterruptedException | ExecutionException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
        }
    }
    
    卖票,ticket=5
    卖票,ticket=5
    卖票,ticket=4
    卖票,ticket=4
    卖票,ticket=3
    卖票,ticket=3
    卖票,ticket=2
    卖票,ticket=1
    卖票,ticket=2
    卖票,ticket=1
    A线程返回结果:票已卖光!
    B线程返回结果:票已卖光!
    
    展开全文
  • 通过Callable接口实现多线程 2016-05-26 12:35 460人阅读 评论(0) 收藏 举报  分类: J2SE(38)  版权声明:本文为博主原创文章,未经博主允许不得转载。 之前通过继承Thread类...
     

    通过Callable接口实现多线程

      460人阅读  评论(0)  收藏  举报
      分类:

    之前通过继承Thread类实现多线程,通过Runnable接口+静态代理实现多线程

    但是有一个不足之处是,重写run方法时没有返回值也不能抛出异常

    使用Callable接口就可以解决这个问题


    Callable接口和Runnable接口的不同之处:

    1.Callable规定的方法是call,而Runnable是run

    2.call方法可以抛出异常,但是run方法不行

    3.Callable对象执行后可以有返回值,运行Callable任务可以得到一个Future对象,通过Future对象可以了解任务执行情况,可以取消任务的执行,而Runnable不可有返回值




    多线程的实现有以下4个步骤:


    1.创建一个线程,创建Callable的实现类Race,并且重写call方法

    ExecutorService ser=Executors.newFixedThreadPool(线程数目);
    Race tortoise = new Race();


    2.得到Future对象

    Future<Integer> result=ser.submit(tortoise);


    3.获取返回值

    int num=result.get();


    4.停止服务

    ser.shutdown();





    举一个龟兔赛跑的例子,直接上代码吧

    [java]  view plain  copy
     print ?
    1. public class Call {  
    2.       
    3.     public static void main(String[] args) throws InterruptedException, ExecutionException {  
    4.           
    5.         ExecutorService ser=Executors.newFixedThreadPool(2);  
    6.           
    7.         Race tortoise=new Race("tortoise",1000);  
    8.         Race rabbit = new Race("rabbit",500);  
    9.           
    10.           
    11.         //获取值  
    12.         Future<Integer> resultR=ser.submit(rabbit);  
    13.         Future<Integer> resultT=ser.submit(tortoise);  
    14.           
    15.         Thread.sleep(3000);  
    16.         rabbit.setFlag(false);  
    17.         tortoise.setFlag(false);  
    18.           
    19.         int numR=resultR.get();  
    20.         int numT=resultT.get();  
    21.           
    22.         System.out.println("rabbit  ---"+numR);  
    23.         System.out.println("tortoise  ---"+numT);  
    24.           
    25.         //停止服务  
    26.         ser.shutdown();  
    27.     }  
    28. }  
    29.   
    30. class Race implements Callable<Integer>{  
    31.       
    32.     private int step=0;  
    33.     private String name;  
    34.     private long time;  
    35.     private boolean flag=true;  
    36.       
    37.     Race(String name,long time){  
    38.         this.name=name;  
    39.         this.time=time;  
    40.     }  
    41.   
    42.     @Override  
    43.     public Integer call() throws Exception {  
    44.         while(flag){  
    45.             Thread.sleep(time);  
    46.             step++;  
    47.         }  
    48.         return step;  
    49.     }  
    50.       
    51.     public void setFlag(boolean flag){  
    52.         this.flag=flag;  
    53.     }  
    54. }  

    展开全文
  • 实现多线程还有一个方法那就是实现Callable接口实现Callable接口实现多线程Thread和Runnable,Callable的区别 实现Callable接口实现多线程 1,实现Callable接口并重写call()方法 public class CallableDemo implements...
  • 在Java中,实现多线程代码有两种方式:一种是继承Thread类;另一种是实现Runnable接口。但是,继承Thread类不能资源共享,而实现Runnable接口可以资源共享。然而,Runnable接口实现多线程会出现Runnable接口中的...
  • 文章目录继承java.lang.Thread(JDK1.0)类,覆写run()方法实现Runnable接口,覆写run()方法继承Thread与实现Runnable的区别实现Callable接口,覆写call()方法 继承java.lang.Thread(JDK1.0)类,覆写run()方法 无论哪种...
  • 使用Runnable接口实现多线程可以避免单线程继承局限,但是Runnable接口实现多线程会存在一个问题:Runnable接口里面run()方法不能返回操作的结果,所以为了解决这样的问题,从JDK1.5开始对于多线程实现提供了...
  • 目录 call方法: Future接口: RunnableFuture接口: 泛型相关基础知识: ...学习callable接口之前先观察collable接口的包: jdk1.5新增的高并发编程包(JUC) package java.util.concurre...
  • 一、继承Thread类实现多线程 Java中有一个java.lang.Thread的类,只要继承了此类就表示:这个类为线程的主体类,但还需要覆写Thread类中提供的一个run()方法,而这个方法就属于线程的主方法(主方法是不能有返回值)...
  • 使用Runnable接口实现多线程可以避免单继承局限,但是Runnable接口实现多线程会存在一个问题:Runnable接口里面的run()方法不能返回操作结果。所以为了解决这样的问题,有了java.util.concurrent.Callable接口,...
  • 在JDK5.0之前,创建线程有2种方式,一种是直接继承Thread,另外一种就是实现Runnable接口。 这2种方式都有一个缺陷...Java实现Callable接口创建多线程: /** * 例子:遍历100以内的偶数,并计算100以内所有偶数的总和
  • * 如何理解实现Callable接口的方式创建多线程实现Runnable接口创建多线程方式强大? * 1. call()可以有返回值的。 * 2. call()可以抛出异常,被外面的操作捕获,获取异常的信息 * 3. C...
  • Java 继承Thread 实现Runnable接口和实现Callable接口创建线程的区别 mycsdn多线程:Java多线程实现方式来分可以分为两类:继承实现和接口实现,相较于继承实现接口避免了单继承的局限性,所以较为常用。实现...
  • JAVA多线程实现方式主要有三种: 继承Thread类、 实现Runnable接口、 使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值,只有最后一种是带返回值的。 1、继承...
  • Java-多线程-实现Callable接口创建线程类 不论是继承自Thread类创建的线程,还是实现Runnable接口创建的线程,都必须重写run方法,但是run方法有两个缺点 不能有返回值 不能抛出异常 所以JDK1.5之后,又有了...
  • 之前了解过了继承Thread类和Runnable接口实现多线程。 下面我们说一下Callable实现多线程Callable实现多线程是在JDK1.5开始追加的开发包:java.uti.concurrent。这个开发包主要是进行高并发编程使用。在这个包...
  • 实现Callable接口实现Runnable接口 我们常见的两种实现多线程编程的方式:实现Runnable接口;继承Thread父类。Thread线程类是Runnable接口的实现类,java类不支持多根继承,类可以实现多个接口,且接口之间...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,759
精华内容 15,103
关键字:

继承callable接口实现多线程