线程的实现

实现线程主要有三种方式:

使用内核线程实现(1:1实现)
使用用户线程实现(1:N实现)
使用用户线程加轻量级进程混合实现(N:M实现)。 “主流”平台上的“主流”商用Java虚拟机的线程模型普遍采用基于操作系统原生线程模型来实现,即采用1:1的线程模型。

使用内核线程实现

使用内核线程实现的方式也被称为1:1实现。内核线程(Kernel-Level Thread,KLT)就是直接由操作系统内核(Kernel,下称内核)支持的线程,这种线程由内核来完成线程切换,内核通过操纵调度器(Scheduler)对线程进行调度,并负责将线程的任务映射到各个处理器上。

程序一般不会直接使用内核线程,而是使用内核线程的一种高级接口——轻量级进程(Light Weight Process,LWP),轻量级进程就是我们通常意义上所讲的线程。

使用用户线程实现

使用用户线程实现的方式被称为1:N实现，狭义上的用户线程（User Thread）指的是完全建立在用户空间的线程库上,系统内核不能感知到用户线程的存在及如何实现的。用户线程的建立、同步、销毁和调度完全在用户态中完成,不需要内核的帮助。

混合实现

线程除了依赖内核线程实现和完全由用户程序自己实现之外,还有一种将内核线程与用户线程一起使用的实现方式,被称为N:M实现。

在这种混合实现下,既存在用户线程,也存在轻量级进程。用户线程还是完全建立在用户空间中。而操作系统支持的轻量级进程则作为用户线程和内核线程之间的桥梁, 这样可以使用内核提供的线程调度功能及处理器映射,并且用户线程的系统调用要通过轻量级进程来完成。

Java线程状态

Java语言定义了6种线程状态,在任意一个时间点中,一个线程只能有且只有其中的一种状态,并且可以通过特定的方法在不同状态之间转换。

这6种状态分别是:

NEW（初始化状态）：创建后尚未启动的线程处于这种状态。
RUNNABLE（可运行 / 运行状态）：包括操作系统线程状态中的Running和Ready,也就是处于此状态的线程有可能正在执行,也有可能正在等待着操作系统为它分配执行时间。
BLOCKED（阻塞状态）：线程被阻塞了,“阻塞状态”与“等待状态”的区别是“阻塞状态”在等待着获取到一个排它锁,这个事件将在另外一个线程放弃这个锁的时候发生;而“等待状态”则是在等待一段时间,或者唤醒动作的发生。在程序等待进入同步区域的时候,线程将进入这种状态。
WAITING（无时限等待）：处于这种状态的线程不会被分配处理器执行时间,它们要等待被其他线程显式唤醒。
TIMED_WAITING（有时限等待）：处于这种状态的线程也不会被分配处理器执行时间,不过无须等待被其他线程显式唤醒,在一定时间之后它们会由系统自动唤醒。
TERMINATED（终止状态）：已终止线程的线程状态,线程已经结束执行。

线程的创建

继承Thread类

（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

（2）创建Thread子类的实例，即创建了线程对象。

（3）调用线程对象的start()方法来启动该线程。

public class Main {
    public static void main(String[] args) {
				// Thread.currentThread()方法返回当前正在执行的线程对象
        System.out.println(Thread.currentThread().getName()+"  : ");
        MyExtendsThread myExtendsThread = new MyExtendsThread();
        myExtendsThread.start();
    }
}

public class MyExtendsThread extends Thread{
    public void run(){
        //GetName()方法返回调用该方法的线程的名字。
        System.out.println(getName());
        System.out.println("hello world");
    }
}

和可以通过lamda表达式重写 Thread 的run方法

public class Main {
    public static void main(String[] args) {
        new Thread(()->{
            System.out.println("hello world lamda");
        }).start();
    }
}

通过Runnable接口

（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

（3）调用线程对象的start()方法来启动该线程。

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("hello world");
    }
}

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

通过Callable和Future

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("hello world MyCallable");
        return "MyCallable return";
    }
}

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        FutureTask<String> future= new FutureTask<>(myCallable);
        new Thread(future).start();
        System.out.println(future.get());
    }
}

使用流创建多线程

IntStream.rangeClosed(1,100).parallel().forEach(i->{
    System.out.println(LocalDateTime.now() + " : " + i);
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) { }
});

通过线程池

ExecutorService executorService = 
Executors.newFixedThreadPool(threadPoolNum, r -> new Thread(r, threadName));

或者 

ExecutorService executorService = new ThreadPoolExecutor(
            2,
            4,
            5,
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(8),
            threadFactory,
            new ThreadPoolExecutor.CallerRunsPolicy());

// 使用
executorService.execute(() -> {
	System.out.println("hello world executorService");
        });

【深入浅出Java多线程】线程基础