一、继承Thread类创建线程类

  • （1）定义Thread类的子类，重写run()方法，run()方法的方法体就代表了线程要完成的任务
  • （2）创建Thread子类的实例，即为创建了线程对象
  • （3）调用线程对象的Start()方法开启线程
public class MyThread extends Thread {
    int i = 0;
    @Override
    public void run() {
        for (; i<100;i++) {
            System.out.println(getName()+" "+i);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if (i == 20){
                new MyThread().start();
                new MyThread().start();
            }
        }
    }
}

上述代码中Thread.currentThread()方法为获取当前正在执行的线程对象，getName()方法返回调用该方法的线程名字.

二、实现Runnable接口创建线程

  • 定义Runnable接口的实现类，并且重写该接口的run() 方法；
  • 创建Runnable实现类的实例，并且将这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象；
  • 调用线程对象的Start()方法来开启线程对象；
public class MyRunnable  implements Runnable{
    private int i = 0;
    @Override
    public void run() {
        for (; i<100;i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if (i == 20){
                MyRunnable myRunnable = new MyRunnable();
                new Thread(myRunnable,"线程一").start();
                new Thread(myRunnable,"线程二").start();
            }
        }
    }
}

三、实现Callable接口和Future创建多线程

  • 创建Callable接口的实现类，并实现Call()方法，该Call()方法作为线程执行体，并且该方法有返回值和抛出异常
  • 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的Call()方法的返回值
  • 使用FutureTask对象作为Thread对象的target创建并启动线程
  • 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class MyCallable implements Callable {
    @Override
    public Integer call() throws Exception {
        int i  = 0;
        for (; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
       return i;
    }

    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+" "+ i);
            if (i == 20){
                new Thread(futureTask,"线程一").start();
            }
        }
        try {
            System.out.println("子线程的返回值"+futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

三种创建线程方式的优劣

通过继承Thread类或者实现Runnable、Callable接口 都可以实现多线程，，实现接口的方式基本相同，只是Callable接口中Call()方法用返回值和声明异常抛出

对于实现接口创建方式的优缺点：

  • 优点
    （1）线程只是实现了接口，还可以继承其他的类
    （2）在这种方式下，多个线程可以共享一个target对象，所以非常适合多个相同线程来处理同一份资源的情况
    从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想
  • 缺点
    （1）编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法
    对于继承Thread方式实现多线程
  • 优点
    （1）编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程
    （2）线程类已经继承了Thread类，所以不能再继承其他父类