本篇介绍Java并发编程基础，内容皆总结摘抄自《Java并发编程的艺术》，仅作笔记。
线程简介
现代操作系统在运行一个程序时，会为其创建一个进程。现代操作系统调度的最小单元是线程，也叫轻量级进程，在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换，让使用者感觉到这些线程在同时执行。
一个Java程序从main()方法开始执行，然后按照既定的代码逻辑执行，看似没有其他线程参与，但实际上Java程序天生就是多线程程序，因为执行main()方法的是一个名为main的线程。
正确使用多线程，总是能够给开发人员带来显著的好出，使用多线程的原因主要有以下几点：
- 更多的处理器核心。线程是大多数操作系统调度的基本单元，一个程序作为一个进程来运行，程序运行过程中能创建多个线程，而一个线程在一个时刻只能运行在一个处理器核心上。这样一来，加入再多的处理器核心也无法显著提高改程序的执行效率。而如果该程序使用多线程技术，将计算逻辑分配到多个处理器核心上，就会显著减少程序的处理时间，随着更多处理器核心的加入而变得更有效率。
- 更快的响应时间。对于一些有复杂业务逻辑的场景，可以使用多线程，将数据一致性不强的操作派发给其他线程处理。好处是响应用户请求的线程能尽可能快的处理完成，缩短了响应时间，提升了用户体验。
- 更好的编程模型。Java为多线程编程提供了良好、考究并且一致的编程模型，为所遇到的问题建立合适的模型，而不是绞尽脑汁的考虑如何将其多线程化。
线程优先级
现代操作系统基本采用时分的形式调度运行的线程，操作系统会分出一个个时间片，线程会分配到若干时间片，当线程的时间片用完了就会发生线程调度，并等待着下次分配。线程分配到的时间片多少决定了线程使用处理器资源的多少，而线程优先级就是决定线程需要多或少分配一些处理器资源的线程属性。
在Java线程中，通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，在线程构建的时候可以通过setPriority(int)方法来修改优先级，默认优先级是5，优先级高的线程分配时间片的数量要多与优先级低的线程。设置线程优先级时，针对频繁阻塞（休眠或I/O操作）的线程需要设置较高优先级，而偏重计算（需要较多CPU时间或偏运算）的线程则设置较低的优先级，确保处理器不会被独占。在不同的JVM或操作系统上，线程规划会存在差异，有些操作系统甚至会忽略对线程优先级的设定。
线程的状态
Java线程在运行的生命周期中可能处于下表中的6种不同的状态，在给定的一个时刻，线程只能处于其中的一个状态。
| 状态名称 | 说明 |
|---|---|
| new | 初始状态，线程被构建，但还没有调用start()方法 |
| runnable | 运行状态，Java线程将操作系统中的就绪和运行两种状态笼统的称为运行中 |
| blocked | 阻塞状态，表示线程阻塞于锁 |
| waiting | 等待状态，表示线程进入等待状态，进入该状态表示当前线程需要等待其他线程做出一些特定动作（通知或中断） |
| time_waiting | 超时等待状态，该状态不同于waiting，它是可以在指定的时间自行返回的 |
| terminated | 终止状态，表示当前线程已经执行完毕 |
线程在自身的生命周期中，并不是固定的出于某个状态，而是随着代码的执行在不同的状态之间进行切换。Java线程状态变迁如下图：
线程创建后，调用start()方法进入就绪状态，当线程获取到CPU时开始执行，进入运行中状态。线程执行wait()方法进入等待状态，进入等待状态的线程需要依靠其他线程的通知才能返回到就绪状态。而超时等待状态相当于在等待状态的基础上增加了超时限制，也就是超时时间达到时将会返回到就绪状态。当线程调用同步方法时，在没有获取到锁的情况下，线程会进入到阻塞状态，在线程获取到同步锁时线程进入就绪状态。线程在执行Runnable的run()方法之后或执行过程中出现异常之后进入到终止状态。
Daemon线程
Daemon时一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。即当一个Java虚拟机不存在非Daemon线程时，Java虚拟机将会退出。可以通过调用Thread.setDaemon(true)将线程设置为Daemon线程。
Runnable和Thread API
在介绍线程实际应用前我们先来了解一下线程相关的API，此处先介绍Runnable以及Thread，其他的会在另外的文章中另作介绍。
Runnable
Runnable接口只有一个run()方法，实现此接口的类在run()方法中实现自己的线程执行体。
public abstract void run();Thread
Thread类代表线程对象，用于操作线程，实现了Runnable接口。Thread类的常用构造函数如下：
//传入Runnable接口的实现类对象
Thread(Runnable target);
//传入Runnable接口的实现类对象并设置线程名称
Thread(Runnable target, String name);常用方法如下：
//获得正在执行的线程对象的引用
public static native Thread currentThread();
//获得线程id
public long getId();
//获得线程名称
public final String getName();
//获得优先级
public final int getPriority();
//获得线程状态
public Thread.State getState();
//中断这个线程，并非立即中断，只是设置一个中断标识
public void interrupt();
//查看线程是否中断，并清除中断标识
public static boolean interrupted();
//此线程是否存活
public final native boolean isAlive();
//是否是守护线程
public final boolean isDaemon();
//线程是否中断，不清除中断标识
public static boolean interrupted();
//等到调用join方法的线程执行完毕再回到当前线程执行
public final void join();
//等到调用join方法的线程执行指定时间后回到当前线程继续执行
public final synchronized void join(long millis);
//设置守护线程
public final void setDaemon(boolean on);
//设置线程名称
public final synchronized void setName(String name);
//设置线程优先级
public final void setPriority(int newPriority);
//当前线程休眠指定时间
public static native void sleep(long millis);
//线程开始执行，即调用run()方法
public synchronized void start();
//当前线程让出CPU，回到就绪状态与其他线程重新竞争
public static native void yield();启动和终止线程
构造线程
在运行线程之前首先要构造一个线程对象，我们可以选择实现Runnable接口和继承Thread类。实现Runnable接口构造线程对象代码如下：
public class MultiThread {
private volatile static boolean flag = false;
public static void main(String[] args) {
//创建Runnable接口实现类对象
MyThread mt = new MyThread();
//创建Thread线程对象，将Runnable实现类作为参数
Thread thread = new Thread(mt);
//启动线程
thread.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = true;
System.out.println("买到票了...");
}
static class MyThread implements Runnable{
@Override
public void run() {
while (!flag) {
System.out.println("在排队呀...");
}
}
}
}就像以上代码中写的，使用实现Runnable接口也要创建Thread类，毕竟操作线程的方法都在Thread类里。另外，启动线程是调用start方法，如果直接调用run方法就只是调用了一个普通的方法，并没有真正启动另外一个线程。
使用继承Thread类构造线程代码如下：
public class MultiThread {
private volatile static boolean flag = false;
public static void main(String[] args) {
//创建Thread类子类对象
MyThread thread = new MyThread();
//设置当前线程名称
thread.setName("排队");
//获取线程id
System.out.println("当前线程id:"+thread.getId());
//获取线程状态
System.out.println("当前线程状态："+thread.getState());
//是否是守护线程
System.out.println("当前线程是否是守护线程："+thread.isDaemon());
//启动线程
thread.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = true;
System.out.println("买到票了...");
}
static class MyThread extends Thread{
@Override
public void run() {
while (!flag) {
System.out.println("在排队呀...");
}
}
}
}继承Thread类后就无需再创建Thread对象，子类可以使用Thread类中的方法来操作线程。上面获取线程状态的返回值是NEW，这与前面介绍线程状态时说的相吻合。
理解中断
中断可以理解为线程的一个标识位属性，它表示一个运行中的线程是否被其他线程进行了中断操作。其他线程通过调用该线程的interrupt()方法对其进行中断操作。
线程通过检查自身是否被中断来响应，线程通过方法isInterrupted()方法来进行判断是否被中断，也可以调用静态方法Thread.interrupted()方法对当前线程的中断标识位进行复位。如果该线程已经出于终结状态，即使该线程被中断过，在调用该线程对象的isInterrupted()方法时仍然会返回false。
下面的例子中，使用interrupted()方法来判断线程是否被其他线程进行了中断操作并且清除了中断标识，因此在main方法中再次调用interrupted()方法返回false。
public class InterruptThread {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread.interrupt();
System.out.println(thread.interrupted());
System.out.println("买到票啦...");
}
}
class MyThread extends Thread{
@Override
public void run() {
while (true) {
if (this.interrupted()){
break;
}
System.out.println("在排队哦...");
}
}
}线程间的通信
线程开始运行，拥有自己的栈空间，就如同一个脚本一样，按照既定的代码一步一步的执行，直到终止。但每个运行中的线程，如果仅仅是孤立的运行，价值就很少，如果多个线程能相互配合完成工作，将会带来巨大的价值。
volatile和synchronized关键字
Java支持多个线程同时访问一个对象或者对象的成员变量，由于每个线程可以拥有这个变量的拷贝，所以程序在执行过程中，一个线程看到的变量不一定是最新的。
关键字volatile可以用来修饰成员变量，告知程序任何对变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新会共享内存，它能保证所有线程对变量访问的可见性。
关键字synchronized可以修饰方法或以同步块的形式来使用，主要确保多个线程在同一时刻，只能有一个线程出于方法或同步块中，它保证了线程对变量访问的可见性和排他性。
任何一个对象都拥有自己的监视器，当这个对象由同步块或者这个对象的同步方法调用时，执行方法的线程必须先获取到该对象的监视器才能进入同步块或同步方法，而没有获取到监视器的线程将会阻塞在同步块或同步方法的入口处，进入阻塞状态。
等待/通知机制
一个线程修改了一个对象的值，另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。前者是生产者，后者就是消费者，这种模式隔离了“做什么”和“怎么做”，在功能层面上实现了解耦，体系结构上具备了良好的伸缩性。
在Java语言中要实现类似的功能，简单的方法时让消费者线程不断地循环检查变量是否符合逾期，如下面代码所示，在while循环中设置不满足的条件，如果条件满足则退出while循环，从而完成消费者的工作。
while(value != desire){
Thread.sleep(1000);
}
doSomething();上面的伪代码在条件不满足时就睡眠一段时间，这样做的目的是防止过快的无效尝试，这种方式看似能实现所需的功能，但存在以下问题：
- 难以确保及时性。在睡眠时，基本不消耗处理器资源，但如果睡的过久，就不能及时发现条件已经变化。
- 难以降低开销。如果降低睡眠时间，这样消费者能更加迅速的发现条件变化，但可能消耗更多的处理器资源。
以上两个问题可以通过Java内置的等待/通知机制解决。等待/通知的相关方法是任意Java对象都具备的，因为这些方法被定义在所有对象的超类java.lang.Object上，方法和描述如下表。
| 方法名称 | 描述 |
|---|---|
| notify() | 通知一个在对象上等待的线程，使其从wait()方法返回，而返回的前提是该线程获取到了对象的锁 |
| notifyAll() | 通知所有等待在该对象上的线程 |
| wait() | 调用该方法的线程进入waiting状态，只有等待另外线程的通知或被中断才会返回，需要注意，调用wait()方法后，会释放对象的锁 |
| wait(long) | 超时等待一段时间，参数时间是毫秒，即等到n毫秒，没有通知就超时返回 |
| wait(long,int) | 对于超时时间更细粒度的控制，可以达到纳秒 |
等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，另一个线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。上述两个线程通过对象O完成交互，而对象上的wait()和notify()/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。
在调用wait()、notify()以及notifyAll()时需要注意以下细节：
- 使用wait()、notify()以及notifyAll()时需要先对对象加锁。
- 调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。
- notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifyAll()的线程释放锁后，等待线程才有机会从wait()返回。
- notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列的所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。
- 从wait()方法返回的前提是获得了对象的锁。
例如在如下代码中创建了两个线程Wait和Notify，前者检查flag是否为false，如果符合要求则进行后续操作，否则在lock上等待，后者在睡眠一段时间后对lock进行通知。
public class WaitAndNotify {
private static boolean flag = true;
private static Object lock = new Object();
public static void main(String[] args) {
Thread threadW = new Thread(new Wait());
Thread threadN = new Thread(new Notify());
threadW.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
threadN.start();
}
static class Wait implements Runnable{
@Override
public void run() {
//加锁，拥有lock的Monitor
synchronized (lock){
System.out.println("等待线程的前半部分工作完成了...");
//条件不满足时，继续wait，同时释放lock的锁
while (flag) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//条件满足时，完成工作
System.out.println("等待线程的后半部分也完成了...");
}
}
}
static class Notify implements Runnable{
@Override
public void run() {
//加锁，获取lock的Monitor
synchronized (lock){
//获取到lock的锁后，先通知，通知时不会释放lock的锁
//当前线程释放了lock的锁之后，等待线程才能从wait()方法返回
lock.notifyAll();
flag = false;
System.out.println("通知线程通知了...");
}
}
}
}
输出结果如下：
等待线程的前半部分工作完成了...
通知线程通知了...
等待线程的后半部分也完成了...Wait线程首先获取了对象的锁，然后调用了对象的wait()方法，放弃了锁并进入了对象的等待队列中，进入等待状态。由于Wait线程释放了对象的锁，Notify线程随后获取了对象的锁，并调用对象的notify()方法，将Wait线程从等待队列移到同步队列中，此时Wait线程的状态变为阻塞状态。Notify线程释放锁之后，Wait再次获取到锁并从wait()方法返回继续执行。
等待/通知的经典范式
从上面的例子中可以提炼出等待/通知的经典范式，该范式分为两部分，分别针对等待方（消费者）和通知方（生产者）。
等待方遵循如下原则：
- 获取对象的锁。
- 如果条件不满足，调用对象的wait()方法，被通知后仍要检查条件。
- 条件满足则执行对应的逻辑。
通知方遵循如下规则：
- 获得对象的锁。
- 改变条件。
- 通知所有等待在对象上的线程。
ThreadLocal
ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上，即一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。也就是说，对于某个ThreadLocal变量，每个线程都有一个变量副本，并且每个线程操作的都是自己本地内存中的副本。
ThreadLocal的常用方法如下：
//返回当前线程的此线程局部变量的值
public T get();
//返回此局部变量在当前线程中的初始值
protected T initialValue();
//删除此局部变量的当前线程的值
public void remove();
//将当前线程的此局部变量的值设置为指定的值
public void set(T value);例如下面的代码，线程A和线程B分别在线程内部设置了ThreadLocal变量，在输出时打印的也是与线程绑定的变量。
public class ThreadLocalTest {
private static ThreadLocal<String> threadLocalStr = new ThreadLocal<>();
public static void main(String[] args) {
MyThreadA threadA = new MyThreadA();
MyThreadB threadB = new MyThreadB();
threadA.start();
threadB.start();
}
static class MyThreadA extends Thread{
@Override
public void run() {
threadLocalStr.set("线程A");
printThread();
}
}
static class MyThreadB extends Thread{
@Override
public void run() {
threadLocalStr.set("线程B");
printThread();
}
}
private static void printThread(){
System.out.println(threadLocalStr.get());
}
}输出结果如下：
线程A
线程B
扫一扫
2949
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
