Java多线程

继承Thread类来实现多线程

继承此类就表示这个类为线程类的主体类，但是需要覆写其中的run()方法（线程的主方法），才可以进场多线程处理。

示例:

// MyThread.java
public class MyThread extends Thread {
    private String title;

    public MyThread(String title) {
        this.title = title;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(this.title);
        }
    }
}

// Main.java
public class Main {
    public static void main(String[] args){
        new MyThread("A").start();
        new MyThread("B").start();
        new MyThread("C").start();
    }
}

1. 示例结果：

   第一次	第二次	第三次
   A A A B C C C B B	A A A B B B C C C	A A A C C C B B B

2. 原因分析：

   1. 三次执行结果不同，原因见我的这篇博客并发，进程，线程简单理解。

      因为线程之间的切换和并发执行的不可见性。

   2. 为何使用start()方法，而不直接调用run()方法，最后的结果还是调用了run()方法。

      调用start()方法来表示该线程启动，标识为当前线程为带执行状态，如果CPU闲置，则可以执行并发调用，请求资源调度，而什么时候调用run()方法，是由系统说明可以调用，通过Java调用的。

基于Runnable接口实现多线程

接口如下：

@FunctionalInterface // 函数式接口
public interface Runnable {
    public abstract void run();
}

由于此接口只有run()方法，需要使用Thread来承载此接口类型变量。

示例：

// MyRunnable.java

public class MyRunnable implements Runnable {
    private String title;

    public MyRunnable(String title) {
        this.title = title;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(this.title);
        }
    }
}

// Main.java
public class Main {
    public static void main(String[] args){
        Thread aThread = new Thread(new MyRunnable("A"));
        Thread bThread = new Thread(new MyRunnable("B"));
        Thread cThread = new Thread(new MyRunnable("C"));

        aThread.start();
        bThread.start();
        cThread.start();
    }
}

此处不再列出结果，由于并发的不可见性，所以结果可能是不一样的。

由于此接口属于函数式接口，当然可以使用Lambda表达式。

Runnable aRunnable = () -> {
    System.out.println("Hello");
};
new Thread(aRunnable).start();

// Hello

new Thread(() -> {
    System.out.println("haha");
}).start();

// haha

多线程设计结构中，使用了代理模式。用户自定义的线程主体只是负责项目核心功能的实现，而所有的辅助实现全部交由Thread类来处理。（后续博客会补上代理设计模式）

卖票程序示例：

// MyThread.java
public class MyThread implements Runnable{
    private int ticket = 5;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (this.ticket > 0) {
                System.out.println("卖票，编号" + (this.ticket --));
            }
        }
    }
}

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

Callable实现多线程

为了解决Runnable线程执行完毕无返回值的问题，JDK1.5后加入了此接口。此接口加入了泛型来设置返回数据类型。Callable源码如下：

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

为了获取该接口的返回值，使用一个Future接口来获取线程执行完毕后的返回值。RunnableFuture接口用来实现Runnable接口和Future接口，FutureTask为实现了RunnableFuture的具体类。

此处使用FutureTask作为测试案例。

// MyThread.java
public class MyThread implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 3; i++) {
            System.out.println("线程执行中，i = " + i);
        }

        return "线程执行完毕";
    }
}

// Main.java
public class Main {
    public static void main(String[] args){
        FutureTask<String> future = new FutureTask<>(new MyThread());
        new Thread(future).start();
        try {
            System.out.println(future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

线程运行状态