Java中的多线程

创建一个多线程的方法

• 继承Thread类

public class MyThread extends Thread{
    //继承Thread类，然后重写run方法;
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("MyThread线程=" + i);
        }
    }
}

public class ThreadDemo1 {
    //main是程序的默认的主线程
    public static void main(String[] args) {
        //创建一个继承了Thread类的对象
        Thread t = new MyThread();
        //调用start方法启动线程，注意启动线程是start方法，而不是run方法;
        t.start();//start()是向CPU注册一个单独的执行流程，那么CUP就会把t作为一个单独的执行流程来执行


        //注意不要把主线程的任务放在启动子线程之前，不然就没意义了
        for (int i = 0; i < 5; i++) {
            System.out.println("main主线程=" + i);
        }

    }
}

注意事项：

        1，线程的启动时start方法而不是run方法。如果调用了run方法，就会被当成普通的方法执行，此时还是相当于单线程；而start方法是向CPU注册一个单独的执行流程，那么CUP就会把它作为一个单独的执行流程来执行

        2，注意不要把主线程的任务放在启动子线程之前，不然主线程任务跑完，然后再执行多线程的任务，那不就没意义了。

• 实现Runnable接口

//1，让一个类实现Runnable接口
public class MyRunnable implements Runnable{
//2，重写run方法;
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程--》" + i);
        }
    }
}
--------------------------------------------------
public class ThreadTest2 {
    public static void main(String[] args) {
        //3，在类中new一个对象
        Runnable myRunnable = new MyRunnable();
        //4，再new一个Thread线程对象，调用线程对象的有参构造器public Thread(Runnable target);
        //5，然后把实现Runnable接口的对象放进构造器去，调用线程对象的start方法即可
        new Thread(myRunnable).start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程--》" + i);
        }
    }
}

实现Runnable接口创建多线程的优点是可以继续继承其他的类，实现其他的接口，扩展性强。缺点硬要说的话就是多一个Runnable对象（其实没啥）

• 使用匿名内部类的形式创建多线程

public class ThreadTest3 {
    public static void main(String[] args) {
        //1,直接创建一个Runnable接口的匿名内部类(任务对象)
        //第一种写法
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程1--》" + i);
                }
            }
        };
        new Thread(target).start();

        //也可以直接更简化的写法
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程2--》" + i);
                }
            }
        }).start();

        //因为Runnable接口带有@FunctionalInterface(函数式接口)的注解，所以他还可以用Lambda表达式来简化
        new Thread(() ->{
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程3--》" + i);
                }
        }).start();

        //主线程
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程--》" + i);
        }

    }
}

其实还是使用实现Runnable接口，然后创建一个线程对象这样的方式来做的，只不过不是一个单独的类，而是匿名内部类来实现而已;

• 实现Callable<V>接口:最大的不同是这种方式多线程跑完可以获取返回值;

//1，创建一个类，实现Callable接口，<V> 可以设置返回值类型
public class CallableTest implements Callable<String> {
    //通过私用属性n来充当下面call方法的传入参数;
    private int n ;
    public CallableTest(int n) {
        this.n = n;
    }
    //2，重写Call方法;
    //重写的call方法，没有办法直接传入参数，但是可以在类中声明一个私有属性，来充当参数：
    @Override
    public String call() throws Exception {
        int sum = 0 ;
        for (int i = 1; i <= n; i++) {
            sum += i ;
        }
        //Thread.sleep(1000);
        return "您求的1到" + n + "的和为:" + sum;
    }
}
------------------------------------------------------
public class MyCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //3创建一个Callable的实例
        //这里的100是我设置的构造器需要带参数而已;
        Callable<String> call = new CallableTest(100);
        //4，Callable自己并不是一个线程对象，需要把他封装到FutureTask未来任务的对象里
            //FutureTask是实现了Runnable接口的
        FutureTask<String> futureTask = new FutureTask<>(call);
        //5,然后在创建一个线程对象，把实现Runnable接口的FutureTask对象放进去;
        new Thread(futureTask).start();
        //然后可以调用FutureTask的get方法获取返回值；
            //注意这里，如果线程没跑完，遇到这个调用返回值的代码他会暂停，不会执行下面的代码
        String s = futureTask.get();
        //System.out.println("hi");
    }
}

重点是通过FutureTask的get()方法，可以获取多线程的返回值;