Java并发 - 线程基础

为什么需要多线程？

众所周知，CPU、内存、I/O 设备的速度是有极大差异的，为了合理利用 CPU 的高性能，平衡这三者的速度差异，计算机体系结构、操作系统、编译程序都做出了贡献，主要体现为：

• CPU 增加了缓存，以均衡与内存的速度差异；// 导致 可见性问题
• 操作系统增加了进程、线程，以分时复用 CPU，进而均衡 CPU 与 I/O 设备的速度差异；// 导致 原子性问题
• 编译程序优化指令执行次序，使得缓存能够得到更加合理地利用。// 导致 有序性问题

线程的使用方式

有三种使用线程的方法：

• 继承Thread类
• 实现Runnable接口
• 实现Callable接口

实现Runnable接口

需要实现run方法，通过Thread调用start方法来启动线程

public class MyRunnable implements Runnable {
    public void run() {
        // ...
    }
}

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

实现Callable接口

与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。

public class MyCallable implements Callable<Integer> {
    public Integer call() {
        return 123;
    }
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
    MyCallable mc = new MyCallable();
    FutureTask<Integer> ft = new FutureTask<>(mc);
    Thread thread = new Thread(ft);
    thread.start();
    System.out.println(ft.get());
}

继承Thread类

同样也是需要实现run方法，因为Thread类也实现了Runnable接口

当调用start方法时，启动一个新线程，虚拟机会将此线程放到就绪队列中等待被调度，该线程被调度时，调用该线程run方法。

public class MyThread extends Thread {
    public void run() {
        // ...
    }
}

public static void main(String[] args) {
    MyThread mt = new MyThread();
    mt.start();
}

实现接口 VS 继承Thread类

实现接口会好一点。因为：

• 一个类只能继承一个类，所以继承了Thread就不可以继承其他类，但却可以实现很多接口
• 类可能只要求可执行就行，继承整个Thread类开销过大

基础线程机制

Executor

Executor管理多个异步任务的执行，而无需程序员显示的管理线程的生命周期，这里的任务指的是任务之间不会互相干扰，不需要同步操作

主要有三种Executor：

• CachedThreadPool：一个任务创建一个线程
• FixedThreadPool: 所有任务只能使用固定大小的线程
• SingleThreadExecutor: 相当于大小为 1 的 FixedThreadPool

Daemon

守护线程是指程序运行时在后台提供服务的线程，不属于程序不可或缺的一部分。当所有非守护线程结束时，程序结束，守护线程也会被强制结束。
main()属于非守护线程。
使用setDaemon()将一个线程设置为守护线程。

public static void main(String[] args) {
    Thread thread = new Thread(new MyRunnable());
    thread.setDaemon(true);
}

sleep()

Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。 注意 sleep属于Thread类哦~

sleep()可能会抛出InterruptedException，因为异常不能跨线程传给main线程，因此必须在本地进行处理。线程中其他抛出的异常同样需要在本地处理~

public void run() {
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

yield()

对于静态方法Thread.yield()声明了当前线程已经完成了生命周期中最重要的一部分！可以切换给其他线程来执行，该方法对于调度器只是一个建议。而且也只是建议有相同优先级的其他线程来执行！

public void run() {
    Thread.yield();
}