多线程（二）

线程的三种创建方式：继承Thread类，实现Runable接口，实现Callable接口

线程的创建方式一：

a.继承Thread类的方式
– 1.定义一个线程类继承Thread类。
– 2.重写run()方法
– 3.创建一个新的线程对象。
– 4.调用线程对象的start()方法启动线程。

public class MyThread extends Thread {
    /**
     2.重写run()方法
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程输出：" + i);
        }
    }
}

    // mian方法启动的时候本身就是属于一个主线程的执行。
    public static void main(String[] args) {
        // 3.创建一个新的线程对象
        Thread t = new MyThread();
        // 4.调用线程对象的start()方法启动线程(启动线程必须用的方法)
        // 最终还是调用run()方法
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程输出：" + i);
        }
    }

继承Thread类的优缺点：
优点：编码简单。
缺点：线程类已经继承了Thread类无法继承其他类了，
功能不能通过继承拓展（单继承的局限性）
小结：
直接定义一个类继承线程类Thread，重写run()方法，创建线程对象
调用线程对象的start()方法启动线程。

线程的创建方式二：

b.实现Runnable接口的方式。
– 1.创建一个线程任务类实现Runnable接口。
– 2.重写run()方法
– 3.创建一个线程任务对象。
– 4.把线程任务对象包装成线程对象
– 5.调用线程对象的start()方法启动线程。

/**
 1.创建一个线程任务类实现Runnable接口
 */
public class MyRunnable implements Runnable{
    /**
     2.重写run()方法
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"#输出："+i);
        }
    }
}

// 匿名内部类写法
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName()+"#输出："+i);
                }
            }
        }).start();

实现Runnable接口创建线程的优缺点：
缺点：代码复杂一点。
– 不能直接得到线程执行的结果！
优点：
– 线程任务类只是实现了Runnable接口，可以继续继承其他类，而且可以继续实现其他接口（避免了单继承的局限性）
– 同一个线程任务对象可以被包装成多个线程对象
– 适合多个多个线程去共享同一个资源

        -- 实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立。
        -- 线程池可以放入实现Runable或Callable线程任务对象。
           注意：其实Thread类本身也是实现了Runnable接口的。

线程的创建方式三：

c.线程的创建方式三: 实现Callable接口。
– 1,定义一个线程任务类实现Callable接口 ， 申明线程执行的结果类型。
– 2,重写线程任务类的call方法，这个方法可以直接返回执行的结果。
– 3,创建一个Callable的线程任务对象。
– 4,把Callable的线程任务对象包装成一个未来任务对象。
– 5.把未来任务对象包装成线程对象。
– 6.调用线程的start()方法启动线程

public class MyCallable implements Callable<String> {
    // 需求返回
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int count = 0;
        for (int i = 1; i <= n; i++) {
            count+=i;
            System.out.println(Thread.currentThread().getName()+":累加：" + i);
        }
        return Thread.currentThread().getName()+"算出1-"+ n+"的和是：" + count;
    }
}

具体实现类：

// 1、创建一个Callable的线程任务对象。
        Callable<String> target = new MyCallable(5);
        // 2、把Callable的线程任务对象包装成一个未来任务对象。
        // -- 未来任务对象可以在线程执行完毕以后去获取线程执行的结果
        // -- 未来任务对象其实就是实现了Runnable接口的实现类象！
        FutureTask<String> task =new FutureTask<>(target);
        // 3、把task任务对象包装成线程对象
        Thread t = new Thread(task);
        // 4、启动线程
        t.start();

        Callable<String> target1 = new MyCallable(6);
        Thread t1 = new Thread(task1);
        t1.start();

// 可以得到线程执行的结果：
        try {
            String result1 = task.get();
            System.out.println(result1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            String result2 = task1.get();
            System.out.println(result2);
        } catch (Exception e) {
            e.printStackTrace();
        }

优点：。
– 线程任务类只是实现了Callable接口，可以继续继承其他类，而且可以继续实现其他接口（避免了单继承的局限性）
– 适合多个多个线程去共享同一个资源
– 线程池可以放入实现Runable或Callable线程任务对象。
– 能直接得到线程执行的结果！(核心作用)
111