创建多线程的三种方式

创建Java多线程的方式：

1.实现Runnable接口+run():
    启动：使用静态代理模式
        1.创建真实角色
        2.创建代理角色Thread+引用
        3.代理角色.start()
2.继承Thread+run()
    启动：创建子类对象+对象.start()

在以上两种方式中推荐使用第一种方式，避免单一继承、便于共享资源

3.通过实现Callable接口实现多线程
优点：可以获取返回值
    Callable接口和Future接口
    Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable接口的类都是可以被其它线程执行的任务。
缺点：繁琐
    思路：
        （1）实现Callable接口+重写call方法并创建对象实例
        （2）借助执行调度服务ExecutorService，获取Future对象
                ExecutorService ser=Executors.newFixedThread(1);
                Future result=ser.submit(实例对象)；
        （3）获取值：result.get()
        （4）停止服务：src.shutdown();

Callable和Runnable有几点不同：
（1）Callable规定的方法是call(),而Runnable规定的方法是run()
（2）call方法可以抛出异常，而run方法是不能的
（3）Callable的任务执行后可以返回值，运行Callable任务可以拿到一个Future对象，Future表示异步计算的结果，它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务的执行情况，可以取消任务的执行，还可以获取任务执行的结果

第一种：

真实角色类：
public class TestThread implements Runnable {
    private boolean flag = true;
    private int num = 0;

    public void stop() {
        this.flag = !this.flag;
    }

    @Override
    public void run() {
        while (flag) {
            System.out.println(Thread.currentThread().getName()+" "+num++);
        }
    }
}

public class TestThread1 {

    public static void main(String[] args) throws InterruptedException {
        TestThread t1=new TestThread();
        Thread proxy=new Thread(t1,"线程A");
        System.out.println(proxy.getName());
        proxy.setName("Test");
        proxy.start();
        System.out.println("启动后的状态 "+proxy.isAlive());
        Thread.sleep(200);
        t1.stop();
        Thread.sleep(100);
        System.out.println("停止后的状态 "+proxy.isAlive());

    }
}

isAlive():判断线程是否还活着；
getName():获取线程名字；

第二种：

public class Wq extends Thread{
    public static void main(String[] args){
        Qe e=new Qe();
        e.start();
    }

}

class Qe extends Thread{
    public void run(){
        System.out.println("Hello!");
    }
}

第三种：

public class wq extends Thread{
    public static void main(String[] args) throws InterruptedException, ExecutionException{
        //创建线程池，大小为2
        ExecutorService ser=Executors.newFixedThreadPool(2);
        Future result1=ser.submit(new Qqq("Hello,"));
        Future result2=ser.submit(new Qqq("Java."));
        ser.shutdown();
    }
}

class Qqq implements Callable{
    String str;
    public Qqq(){
        super();
    }
    public Qqq(String str){
        this.str=str;
    }
    @Override
    public Object call() throws Exception {
        System.out.print(str);
        return null;
    }
}

输出：
Hello,Java.