线程基础

进程和线程

一个操作系统可以同时运行多个进程（Process），进程是操作系统资源分配调度的最小单位，共有以下几种特性：

1. 独立性，拥有独立资源，私有地址空间。进程间不可以直接互相访问
2. 动态性，程序是一个静态指令集合，而进程是一个在系统中活动的指令集合，具有自己的生命周期和状态
3. 并发性，多个进程可以在单个处理器上并发执行

并行（parallel）： 在同一时刻，有多个指令在cpu执行，多核cpu才可以并行
并发（concurrency）： 在同一时刻，只有一个指令在cpu执行，但是多个进程指令会被快速轮换执行，宏观上具有同时执行的效果

线程（Thread），是一个轻量级进程（Lightweight Process），是进程的执行单元，是一个独立的并发的执行流。具有以下几个特点：

1. 一个线程必须有自己的父进程
2. 一个进程可以包含一个或者多个进程，至少包含一个
3. 进程中的线程共享进程变量
4. 并发性
5. 独立性

线程相比进程，有如下优势：

1. 进程之间不可共享内存，线程共享内存很容易
2. 系统创建进程，需要为进程分配系统资源，效率低，而创建线程则很简单，所以线程拥有更高的效率

在Java中创建线程

方式一：继承Thread

class Thread1 extends Thread {
    @Override
    public void run() {
        System.out.println("线程1---");
    }
}

方式二：实现Runnable

class Thread2 implements Runnable {
    @Override
    public void run() {
        System.out.println("线程2---");
    }
}

方式三：Callable 和 Future

上述两种方法，都无法获取线程的执行结果（run方法没有返回值），不够强大，所以 java5 提供了 Callable 接口，作为thread的 target，有返回值——即有返回结果的线程。

注意：

1. callable对象不可以直接作为thread的target
2. jdk5 提供了 Future 接口作为 call 方法的返回值
3. FutureTask 实现了 Future 和 Runnable 接口，可以作为Thread的target

同时，Future接口里定义了公共方法，用于控制关联的Callable任务：

1. cancel 试图取消callable任务
2. isCancelled 如果Callable未执行完前被取消，返回true
3. get 获取call方法返回值，如果线程未执行完，此操作可能会使线程阻塞（可以设置超时时间）
4. isDone 是否执行完成

public class CallableTest implements Callable {
    @Override
    public Object call() throws Exception {
        Thread.sleep(3 * 1000);
        // 从网络获取数据
        return Thread.currentThread().getName() + "我是数据";
    }

    public static void main(String[] args) {

        CallableTest callable = new CallableTest();
        FutureTask futureTask = new FutureTask(callable);
        Thread thread1 = new Thread(futureTask, "线程1");
        thread1.start();
        // 获取线程返回值
        try {
            Object o = futureTask.get();
            System.out.println(o); // 线程1我是数据
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

三种创建方式对比

• 因为Java只支持单继承，所以实现Runnable和Callable接口还可继承其他类，所以比继承Thread更为灵活
• 实现Runnable和Callable接口可以方便的进行变量共享（在实现类中定义共享变量）
• Callable有返回值，而Runnable没有返回值
• 所以优先使用Runnable和Callable

线程生命周期

线程共有六种状态：

• NEW 新建状态
• RUNNABLE 可运行/运行状态，被调度器选中的是运行状态，未被选中的则是可运行状态(就绪状态)
• BLOCKED 阻塞状态
• WAITING 无限等待状态，比如wait()无限等待直到被notiy()才继续执行
• TIMED_WAITING 有时限等待状态，比如sleep(5000)睡五秒钟
• TERMINATED 终止状态

线程类Thread中含有一个表示线程状态内部类State，可通过thread.getState()获取线程当前状态

控制线程

join

t1.join([支持等待毫秒数])： 将t1线程加入到当前线程，等待t1执行完毕后，再执行当前线程

用于控制线程的执行顺序，保证当前逻辑在t1线程执行完毕后再执行。比如网络请求线程

private static void testJoin() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
                System.out.println("线程1执行..." + i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "线程1");
    t1.start();
    // 将线程1join到主线程中
    t1.join();
    // 主线程代码执行
    System.out.println("--main--");
}
/*
线程1执行...1
线程1执行...2
线程1执行...3
线程1执行...4
--main--
*/

yield

线程让步：回归到Ready状态，让线程调度器重新调度

private static void testYield() {
    Runnable runnable = () -> {
        for (int i = 0; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + "-----" + i);
            if (i % 4 == 0) {
                Thread.yield();
            }
        }
    };
    new Thread(runnable, "线程1").start();
    new Thread(runnable, "线程2").start();
}
/*
线程1-----0      0 % 4 = 0 让步给线程2
线程2-----0
线程2-----1
线程2-----2
线程2-----3
线程2-----4      4 % 4 = 0 让步给线程1
线程1-----1
...
*/

sleep

可以将当前线程置为阻塞状态，可以传递一个毫秒值，什么时候唤醒由线程调度决定。

public static void main(String[] args) throws Exception {
	System.out.println(new Date());
	Thread.currentThread().sleep(3 * 1000);
	System.out.println(new Date());
}

结果：

Mon Feb 18 16:22:48 CST 2019
Mon Feb 18 16:22:51 CST 2019

线程中断

经常会有停止线程中断线程的需求，可以通过java提供的 stop(), suspend() 方法，实现，但是这些方法都具有安全性问题，已经被废弃，官方推荐 interrupt()方法。

共有三个方法控制线程中断：

• interrupt()，在一个线程中调用另一个线程的interrupt()方法，即会向那个线程发出信号——线程中断状态已被设置。仅仅是设置状态，不会对代码由任何影响，具体操作需要程序员自己实现。
• isInterrupted()，用来判断当前线程的中断状态(true or false)。
• interrupted()是个Thread的static方法，用来恢复中断状态。

守护线程

在Java中，线程分为 User Thread 和 Daemon Thread。如果在JVM中，有任意一个User Thread未结束，那么所有的守护线程就不会结束；如果所有的User Thread结束了，那么所有的Daemon Thread也会跟着结束。守护线程通常用于给应用程序提供相应的服务，比如GC就是一个守护线程。

设置一个守护线程很简单：

// 注意，此方法需要在start()之前调用
t.setDaemon(true);

注意：

• 主线程不能设置未守护线程
• 守护线程产生的子线程仍然是一个守护线程

线程优先级

设置线程优先级：

Thread.currentThread().setPriority(10); 

优先级大小范围为：

Thread.MAX_PRIORITY // 10
Thread.MIN_PRIORITY // 1
Thread.NORM_PRIORITY // 5