Java 多线程

Java 多线程

线程：在系统上运行的一组指令的集合，或者程序的特殊段，可以独立执行。它负责在单个程序中执行多个任务。
进程：正在运行的程序的实例。

并行: 在计算机语言环境中,并行是指多个线程同时执行。如果计算机系统要并行执行多个任务，在现行的计算机系统下，必须要求计算机有多个中央处理器核心，也就是多核CPU。并发:并发是指通过计算机处理器核心通过相应的算法，将有限的计算资源以时间为单位分割，在一段时间内执行一个线程，下一个时间段内执行下一个线程。由于从计算机维度的时间间隔对于人类视角也只是一瞬间，所以人类从宏观角度来看好像就是计算机在同一时刻同时执行多个任务。

多线程：指从软件或者硬件层面上实现多个线程并发执行的技术。

Java语言环境下，实现多线程的方式：

继承Thread：

class MultiThreadDemo{
    private void chilByHirThread() {
        // 继承了Thread
        ChilThread chilThread = new ChilThread();
        // 主线程
        System.out.println(Thread.currentThread()+"this is the main thread");
        // 子线程开启
        chilThread.start();
    }
}

// 继承Thread 实现多线程
class ChilThread extends Thread{
    // 子线特有方法
    public void soutEat(){
        System.out.println(Thread.currentThread()+"eat in another thread");
    }

    // 重写方法
    @Override
    public void run() {
        soutEat();
    }

    // 子线程开启方法
    @Override
    public void start(){
        super.start();
    }
}

实现Runnable接口与实现Callable接口：

public class MultiRuannableDemo {
    public static void main(String[] args) throws Exception {

        // runnable 多线程实现方式
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr,"runnable子线程");
        t1.start();
        
        // callable 多线程实现方式
        MyCallable mc = new MyCallable();
        // callable多任务执行器
        FutureTask t = new FutureTask(mc);
        Executor executor = Executors.newSingleThreadExecutor();
        executor.execute(t);
        // 如果需要的到子线程的返回值,则到此处主线程处于阻塞状态,必须等到子线程执行结束返回返回值
        System.out.println(t.get().toString());
        for (int i = 0; i < 20; i++) {
            System.out.println("当前线程" + Thread.currentThread().getName() + "计数" + i);
            Thread.sleep(300);
        }

    }
}

class MyCallable implements Callable{
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 20; i++) {
            System.out.println("当前线程" + Thread.currentThread().getName() + "计数" + i);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return "子线程结束";
    }
}

class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("当前线程" + Thread.currentThread().getName() + "计数" + i);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 匿名内部类实现多线程
public class MultiTreadAnyInnerClass {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 匿名内部类实现runnable
        innerRunnable();
        // 匿名内部类实现callable
        innerCallable();

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread());
        }
    }
    
    private static void innerCallable() throws InterruptedException, ExecutionException {
        FutureTask<String> t = new FutureTask<>
                (new Callable<String>() {
            @Override
            public String call() throws Exception {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread());
                }
                return "子线程结束";
            }
        });
        Executors.newSingleThreadExecutor().execute(t);
        System.out.println(t.get());
    }

    private static void innerRunnable() {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread());
                }
            }
        };
        new Thread(r).start();
    }
}

区别：

1. 实现callable接口的任务可以回调（返回）执行结果，而实现runnable接口的任务无法返回执行结果。

2. Callable 接口的call()方法允许跑出异常，而Runnable接口的run()方法异常只能在内部处理，不能继续向上抛出。

3. Callable 接口支持返回结果，返回结果需要调用FutureTask.get()方法来获取返回值，Callable获取返回值会使主线程（开启子线程的线程）陷入阻塞状态，主线程必须等到子线程获取结果；当不调用此方法获取返回值的时候，不会阻塞。

4. 继承Thread 的多线程实现方式不适合资源共享，而实现Runnable接口方式更加适合资源共享。 Runnable可以避免Java种的单继承的局限性。

线程生命周期：

当线程被创建并启动以后，并不是一启动就进入执行状态，也不是一直处于执行状态，而是有自己的生命周期，根据java.lang.Thread.state API，在线程的生命周期中，有以下6种状态。

线程安全：待续。。。