Java学习笔记之--------线程（四）多线程的实现

Java中实现多线程，常用的方法有三种：通过创建Thread类的实例来实现，通过Runnable接口实现，通过Callable接口实现。

1.通过创建Thread类的实例来实现

在Java中负责线程的这个功能的是java.lang.Thread这个类，可以通过创建Thread的实例来创建新的线程，每个线程都是通过某个特定的Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。实例如下。

public class Rabbit extends Thread {
    // 继承Thread+重写run(线程体)
    @Override
    public void run() {
        for (int i = 0; i < 120; i++) {
            System.out.println("兔子跑了" + i + "步");
        }
    }
}

class Tortoise extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 120; i++) {
            System.out.println("乌龟跑了" + i + "步");
        }
    }
}

public class RabbitApp {
    public static void main(String[] args) {
        // 创建对象
        Rabbit rab = new Rabbit();
        // 调用start方法，不要调用run方法
        rab.start();

        Tortoise tor = new Tortoise();
        tor.start();
    }
}

运行结果如下：

如果调用run()方法，则不会体现多线程。

2.通过Runnable接口实现

继承Thread类方法的缺点：我们的类如果已经从一个类继承，就无法继承Thread类，所以，我们可以通过实现Runnable接口实现多线程。通过实现Runnable接口实现多线程的优点：避免单继承，方便共享资源，同一份资源，多个代理访问。实例如下。

public class Web12306 implements Runnable {
    // 假定有50张票
    private int num = 50;

    @Override
    public void run() {
        while (true) {
            if (num <= 0) {
                break;// 跳出循环
            }
            System.out.println(Thread.currentThread().getName() + "抢到了" + num--);
        }
    }

    public static void main(String[] args) {
        Web12306 web12306 = new Web12306();

        Thread t1 = new Thread(web12306, "张三");
        Thread t2 = new Thread(web12306, "李四si");
        Thread t3 = new Thread(web12306, "王五五五");

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果如下图所示：

这种实现多线程的方法涉及到了代理模式，初学者可以先了解一下，以后学习设计模式的时候再详细了解代理模式。

3.通过Callable接口实现

除此之外，我们还可以通过Callable接口实现多线程。Callable是类似于Runnable的接口，实现Callable接口和实现Runnable接口的类都是可被其他线程执行的任务。通过Callable接口实现多线程的优点：可以获取返回值。缺点：过程比较繁琐。

通过Callable接口实现和通过Runnable接口实现的几点不同：
①Callable规定的方法是call()，而Runnable规定的方法是run()。
②call()方法可以抛出异常，而run()方法是不能抛出异常的。
③Callable的任务执行后可返回值，运行Callable任务可以拿到一个Future对象，而Runnable的任务是没有返回值的。

Future是一个接口，代表了一个异步计算的结果。接口中的方法用来检查计算是否完成、等待完成和得到计算的结果。当计算完成后，只能通过get()方法得到结果，get方法会阻塞直到结果准备好了。如果想取消，那么调用cancel()方法。其他方法用于确定任务是正常完成还是取消了。一旦计算完成了，那么这个计算就不能被取消。

示例代码如下，此处重新实现龟兔赛跑的代码。

public class Call {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 创建线程
        ExecutorService ser = Executors.newFixedThreadPool(2);
        Race tortoise = new Race("乌龟", 1000);
        Race rabbit = new Race("兔子", 500);
        // 获取值
        Future<Integer> result1 = ser.submit(tortoise);
        Future<Integer> result2 = ser.submit(rabbit);
        // 让龟兔跑2秒
        Thread.sleep(2000);
        // 停止线程体循环
        tortoise.setFlag(false);
        rabbit.setFlag(false);
        // 获取结果
        int num1 = result1.get();
        int num2 = result2.get();
        System.out.println("乌龟跑了---->" + num1 + "步");
        System.out.println("兔子跑了---->" + num2 + "步");
        // 停止服务
        ser.shutdownNow();
    }
}

class Race implements Callable<Integer> {
    private String name;// 名称
    private long time;// 延时时间
    private boolean flag = true;
    private int step = 0;

    public Race() {
    }

    public Race(String name) {
        super();
        this.name = name;
    }

    public Race(String name, long time) {
        super();
        this.name = name;
        this.time = time;
    }

    @Override
    public Integer call() throws Exception {
        while (flag) {
            Thread.sleep(time);
            step++;
        }
        return step;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public long getTime() {
        return time;
    }
    public void setTime(long time) {
        this.time = time;
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    public int getStep() {
        return step;
    }
    public void setStep(int step) {
        this.step = step;
    }

}

运行结果如下：

这里介绍了三种实现多线程的方法，在实际应用中根据实际需求选择自己要使用的。