JAVA多线程(2)-----线程的创建

Java中主要提高了三种方式来创建线程

1)继承Thread类

2)实现Runnable接口

3)使用Callable和Future

---------------------继承Thread类-------------------

一般步骤如下:

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

2、创建Thread子类的实例,也就是创建了线程对象

3、启动线程,即调用线程的start()方法

代码实例:

public class Main {
    public static void main(String[] args){
        MyThread myThread=new MyThread();
        myThread.start();
    }
}

class MyThread extends Thread{
    @Override
    public void run(){   
        //重新run()方法
    } 
}


--------------------实现Runnable接口-----------------

一般步骤如下:

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

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

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

代码实例:

public class Main {
    public static void main(String[] args){
        Thread thread=new Thread(new MyRunnable());
        thread.start();
    }
}
class MyRunnable implements Runnable{
    public void run(){
       //实现run()方法
    }
}


-----------------------使用Callable和Future------------------------

和Runnable接口不一样,Callable接口提供了一个call()方法作为线程执行体,call()方法比run()方法功能要强大。

  • call()方法可以有返回值
  • call()方法可以声明抛出异常

Java5提供了Future接口来代表Callable接口里call()方法的返回值,并且为Future接口提供了一个实现类FutureTask,这个实现类既实现了Future接口,还实现了Runnable接口,因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。

>boolean cancel(boolean mayInterruptIfRunning):试图取消该Future里面关联的Callable任务

>V get():返回Callable里call()方法的返回值,调用这个方法会导致程序阻塞,必须等到子线程结束后才会得到返回值

>V get(long timeout,TimeUnit unit):返回Callable里call()方法的返回值,最多阻塞timeout时间,经过指定时间没有返回抛出TimeoutException

>boolean isDone():若Callable任务完成,返回True

>boolean isCancelled():如果在Callable任务正常完成前被取消,返回True

一般步骤如下:

1、创建Callable接口的实现类,并实现call()方法,然后创建该实现类的实例(从java8开始可以直接使用Lambda表达式创建Callable对象)

2、使用FutureTask类来包装Callable对象,该FutureTask对象封装了Callable对象的call()方法的返回值

3、使用FutureTask对象作为Thread对象的target创建并启动线程(因为FutureTask实现了Runnable接口)

4、使用FutureTask对象作为Thread对象的target创建并启动线程(因为FutureTask实现了Runnable接口)

代码实例:

public class Main {
    public static void main(String[] args){
        System.out.println(Thread.currentThread().getName()+"主线程开始运行");
        Callable<Integer> c= new MyCallable();
        FutureTask<Integer> future=new FutureTask<Integer>(c);
        new Thread(future,"有返回值的线程").start();
        try{
            System.out.println("子线程返回值:"+future.get());
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"主线程结束运行");
    }
}

class MyCallable implements Callable<Integer>{
    public Integer call() throws Exception{
        return 5;
    }
}

-------------------3种方法比较-----------------------------

实现Runnable和实现Callable接口的方式基本相同,不过是后者执行call()方法有返回值,后者线程执行体run()方法无返回值,因此可以把这两种方式归为一种这种方式与继承Thread类的方法之间的差别如下:

  1. 线程只是实现Runnable或实现Callable接口,还可以继承其他类。
  2. 这种方式下,多个线程可以共享一个target对象,非常适合多线程处理同一份资源的情形。
  3. 但是编程稍微复杂,如果需要访问当前线程,必须调用Thread.currentThread()方法。
  4. 继承Thread类的线程类不能再继承其他父类(Java单继承决定)。
阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页