Java并发原理（二）——线程基础

目录

线程状态转换

线程中断

线程使用方式

---

线程状态转换

新建(New)

创建后尚未启动。

可运行（Runnable）

可能正在运行，也可能正在等待 CPU 时间片。

包含了操作系统线程状态中的 Running 和 Ready。

阻塞（Blocking）

等待获取一个排它锁，如果其线程释放了锁就会结束此状态。

无限期等待（Waiting）

等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。

进入方法	退出方法
没有设置 Timeout 参数的 Object.wait() 方法	Object.notify() / Object.notifyAll()
没有设置 Timeout 参数的 Thread.join() 方法	被调用的线程执行完毕
LockSupport.park() 方法	-

限期等待（Timed Waiting）

无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。

调用 Thread.sleep() 方法使线程进入限期等待状态时，常常用“使一个线程睡眠”进行描述。

调用 Object.wait() 方法使线程进入限期等待或者无限期等待时，常常用“挂起一个线程”进行描述。

睡眠和挂起是用来描述行为，而阻塞和等待用来描述状态。

阻塞和等待的区别在于，阻塞是被动的，它是在等待获取一个排它锁。而等待是主动的，通过调用 Thread.sleep() 和 Object.wait() 等方法进入。

进入方法	退出方法
Thread.sleep() 方法	时间结束
设置了 Timeout 参数的 Object.wait() 方法	时间结束 / Object.notify() / Object.notifyAll()
设置了 Timeout 参数的 Thread.join() 方法	时间结束 / 被调用的线程执行完毕
LockSupport.parkNanos() 方法	-
LockSupport.parkUntil() 方法	-

死亡（Terminated）

可以是线程结束任务之后自己结束，或者产生了异常而结束。

线程中断

Thread的interrupt方法是中断线程。其实，Java的中断是一种协作机制。也就是说调用线程对象的interrupt方法并不一定就中断了正在运行的线程，它只是要求线程自己在合适的时机中断自己。每个线程都有一个boolean的中断状态（中断位），interrupt方法仅仅只是将该状态置为true。

（1）可以通过Thread的类方法interrupted检查当前线程是否中断，但是会重置标志位，比如由true置为false（true表示中断）

（2）通过调用Thread的普通方法isInterrupted来检查中断位，不会重置标志位。

中断线程方法：（1）通过检查标志位用break退出循环（2）通过return退出run方法（3）通过对有些状态中断抛异常退出。（4）当循环判断的条件不满足时，run方法执行完毕线程自然会退出；

Thread.yield( )方法：使当前线程从执行状态（运行状态）变为可执行态（就绪状态）。cpu会从众多的可执行态里选择，也就是说，当前也就是刚刚的那个线程还是有可能会被再次执行到的，并不是说一定会执行其他线程而该线程在下一次中不会执行到了。

thread.join（）调用该方法的线程等待被调用的线程执行完毕后才执行

wait() vs sleep()

1、每个对象都有一个锁来控制同步访问，Synchronized关键字可以和对象的锁交互，来实现同步方法或同步块。sleep()方法正在执行的线程主动让出CPU（然后CPU就可以去执行其他任务），在sleep指定时间后CPU再回到该线程继续往下执行(注意：sleep方法只让出了CPU，而并不会释放同步资源锁！！！)；wait()方法则是指当前线程让自己暂时退让出同步资源锁，以便其他正在等待该资源的线程得到该资源进而运行，只有调用了notify()方法，之前调用wait()的线程才会解除wait状态，可以去参与竞争同步资源锁，进而得到执行。（注意：notify的作用相当于叫醒睡着的人，而并不会给他分配任务，就是说notify只是让之前调用wait的线程有权利重新参与线程的调度）；

2、sleep()方法可以在任何地方使用；wait()方法则只能在同步方法或同步块中使用；

3、sleep()是线程线程类（Thread）的方法，调用会暂停此线程指定的时间，但监控依然保持，不会释放对象锁，到时间自动恢复；wait()是Object的方法，调用会放弃对象锁，进入等待队列，待调用notify()/notifyAll()唤醒指定的线程或者所有线程，才会进入锁池，不再次获得对象锁才会进入运行状态；

在线程wait或sleep时，使用thread的interrupt方法（不是静态方法）都会响应中断。

此时，执行interrupt()时,并不需要获取Thread实例的锁定。任何线程在任何时刻,都可以调用其他线程的interrupt()方法.当正在sleeping的线程被调用interrupt()方法时,就会放弃暂停的状态，并抛出InterruptedException异常，这个异常是A线程抛出的。 wait() & interrupt() 线程A调用了wait()进入了等待状态,也可以用interrupt()取消。不过这时候要小心锁定的问题。线程进入等待区,会把锁定解除,当对等待中的线程调用interrupt()时(注意是等待的线程调用其自己的interrupt()),会先重新获取锁定,再抛出异常。在获取锁定之前,是无法抛出异常的.

线程使用方式

有三种使用线程的方法:

• 实现 Runnable 接口；

• 实现 Callable 接口；

• 继承 Thread 类。

实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。

实现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 类也实现了 Runable 接口。

当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。

public class MyThread extends Thread {
    public void run() {
        // ...
    }
}
​
public static void main(String[] args) {
    MyThread mt = new MyThread();
    mt.start();
}
​

使用线程池

好处：第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二：提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。第四：Java1.5中引入的Executor框架把任务的提交和执行进行解耦，只需要定义好任务，然后提交给线程池，而不用关心该任务是如何执行、被哪个线程执行，以及什么时候执行。

Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService，Executors是一个框架，ThreadPoolExecutor是线程池实现的核心类。

可以使用Executors框架中的静态工厂方法之一来创建一个线程池：（如果线程池中抛出异常，内部会被try，catch掉。可以通过future.get()捕获异常）

newFixedThreadPool：创建一个固定长度的线程池，每当提交一个任务时就创建一个线程，直到达到线程池的最大数量，这时线程池的规模将不再变化（如果某个线程由于发生了未预期Exception而结束，那么线程池会补充一个新的线程）。

newCachedThreadPool：创建一个可缓存的线程池，如果线程池当前规模超过了处理需求，那么将回收空间线程，而当需求增加时，可以添加新线程，线程池规模不存在任何限制（不推荐使用，线程池规模不可控）大小为Integer.MAX_VALUE，2的31次方-1。

newSingleThreadExecutor：是一个单线程的Executor，如果这个线程异常结束，会创建另一个线程替代，它能保证依照任务在队列中的顺序串行执行(FIFO, LIFO, 优先级)。

newScheduledThreadPool：创建一个固定长度的线程池，而且以延迟或定时的方式来执行任务，类似于Timer。

ExecutorService threadPool = Executors.newFixedThreadPool(3);

ExecutorService threadPool = Executors.newCachedThreadPool();

ExecutorService threadPool = Executors.newSingleThreadExecutor();

threadPool.execute(Runnable r);

threadPool.shutdown();将任务执行完毕后关闭

threadPool.shutdownNow();立即关闭，并返回没有执行的任务（List<Runnable>）

对于计算密集型的任务，在拥有N个cpu的系统上，当线程池的大小为N+1时，通常能实现最优利用率。对于I/O密集型，通常线程池大小为2*N。