文章目录
1 进程与线程
1.1 概念
进程：一个在内存中运行的应用程序。它是系统资源分配的基本单位（包括内存地址空间），因此各个进程拥有的内存地址空间相互独立。
线程：进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。 它是处理器任务调度和执行的基本单位。
1.2 区别
- 根本区别： 进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位；
- 资源开销：
- 每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；
- 线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。
- 包含关系：线程是进程的一部分，一个进程可包括一个或多个线程；
- 内存分配：同一进程的线程共享本进程的地址空间和资源，而进程之间的地址空间和资源是相互独立的；
- 影响关系：一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。
- 执行过程：每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发执行。
1.3 线程状态及转换
线程的状态及转换图：
- NEW新建：创建了一个线程
- Runnable：可运行状态
- Blocked：阻塞状态
- 等待阻塞：运行状态中的线程执行 wait()方法，JVM会把该线程放入等待队列(waitting queue)中，使本线程进入到等待阻塞状态；
- 同步阻塞：线程在获取 synchronized 同步锁失败(因为锁被其它线程所占用)，则JVM会把该线程放入锁池(lock pool)中，线程会进入同步阻塞状态；
- 其他阻塞：通过调用线程的 sleep()或 join()或发出了 I/O 请求时，线程会进入到阻塞状态。当 sleep()状态超时、join()等待线程终止或者超时、或者 I/O 处理完毕时，线程重新转入就绪状态。
- Waiting：永久等待
- Time_Waiting：计时等待/休眠状态
- Terminated：死亡状态
1.4 常用的线程方法：
1、join()方法：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
2、yield()方法：Thread.yield() 方法，使当前线程由执行状态，变成为就绪状态，让出cpu时间，在下一个线程执行时候，如果该线程获得了CPU时间片，那就可以运行，不然还是处于就绪状态。
3、sleep(long millitime)方法：sleep(long millitime)：让当前线程“睡眠”指定的millitime毫秒。
- 在指定的millitime毫秒时间内，当前线程是阻塞状态；
- 如果在睡眠期间，其他线程调用了该线程的interrupt()方法中断了该线程，则该线程会在调用sleep()方法的地方抛出InterruptedException异常。
4、wait()方法：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁；
5、notify()方法和notifyAll()方法：都是唤醒线程的方法，唤醒的线程移到锁池中，等待获取CPU时间片。
- notify()方法，随机唤醒一个处于等待状态的线程；
- notifyAll()方法，唤醒所有的线程。
使用wait()、notify()和notifyAll()方法的注意细节：
- 使用wait()、notify()和notifyAll()时需要先对调用对象加锁。即先对调用这些方法的对象加锁；
- 调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列；
- notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifAll()的线程释放锁之后，等待线程才有机会从wait()返回；
- notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中的所有线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。
- 从wait()方法返回的前提是获得了调用对象的锁。
1.5 什么是线程安全
当多个线程同时访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那就称这个对象是线程安全的。
1.6 Java线程调度
线程调度是指系统为线程分配处理器使用权的过程。分类：
- 协同式线程调度
- 抢占式线程调度
1.6.1 协同式调度
- 特点：线程的执行时间由线程本身来控制，线程把自己的工作执行完之后，必须要主动通知系统切换到另外一个线程上。
- 好处：实现简单；切换线程对线程自己是可知的，所以没有什么线程同步的问题
- 缺点：线程执行时间不可控制，如果一个线程编写有问题，一直不告知操作系统进行线程切换，那么程序就会一直阻塞在这里。这样使得一个进程时钟不让出CPU执行时间，会导致整个系统崩溃
1.6.2抢占式调度
- 特点：每个线程将由系统分配执行时间，线程的切换不由线程本身来决定（在Java中，Thread.yield()方法虽然可以让出执行时间，但是线程要获取执行时间的话，线程本身没有任何办法）
- 好处：线程的执行时间可控，不会有一个线程导致整个进程阻塞的问题
- Java使用的线程调度就是抢占式调度
1.7 线程中断
Java中的线程中断是一种线程间的协作模式，通过设置线程的中断标志并不能直接终止该线程的执行，而是被中断的线程根据中断状态自行处理。
- void interrupt()方法：中断线程，例如，当线程A运行时，线程B可以调用线程A的interrupt()方法来设置线程A的中断标志为true并立即返回。
- 设置标志仅仅是设置标志，线程A实际并没有被中断，它会继续向下执行。
- 如果线程A因为调用了wait系列函数、join方法或者sleep方法而被阻塞挂起，这时候若线程B调用线程A的interrupt()方法，线程A会在调用这些方法的地方抛出InterruptedException异常而返回。挂起状态的线程不能被中断，也就是说，中断会出现异常。
- void isInterrupted()方法：检测当前线程是否被中断，如果是（表示当前线程中断）返回true，否则返回false。
- boolean interrupted()方法：检测当前线程是否被中断，如果是返回true，否则返回false。
- 与isInterrupted()不同的是，该方法如果发现当前线程被中断，则会清除中断标志。
- 该方法是static方法，可以通过Thread类直接调用。
- 在interrupted()内部获取的是：当前调用线程的中断标志，而不是调用interrupted()方法的实例对象的中断标志。
2 线程间通信
2.1 等待—通知机制
一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。前者是生产者，后者就是消费者，这种模式隔离了“做什么”（what）和“怎么做”（How），在功能层面上实现了解耦，体系结构上具备了良好的伸缩性。Java语言如何实现？？？
简单的办法是让消费者线程不断地循环检查变量是否符合预期，如下面代码所示，在while循环中设置不满足的条件，如果条件满足则退出while循环，从而完成消费者的工作。
while(value != exception){
Thread.sleep(1000);
}
doSomething();
上述代码存在的问题：
- 无法保证及时性：在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证；
- 难以降低开销：如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。
Java通过内置的等待—通知机制解决上述问题。
2.2 等待—通知范式
步骤：
- 加锁；
- 条件循环；
- 处理逻辑
等待—通知分为两部分：等待方(消费者) 和 通知方(生产者)。遵循的原则如下：
-
消费者（等待方）的原则：
- 获取对象的锁；
- 如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件；
- 条件满足则执行对应的逻辑。
synchronized(对象) { while(条件不满足) { 对象.wait(); } 对应的处理逻辑 } -
生产者（通知方）
- 获得对象的锁；
- 改变条件；
- 通知所有等待在对象上的线程。
synchronized(对象) { 改变条件; 对象.notifyAll(); }
生产者消费者代码实例
public class Communication{
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"add").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"sub").start();
}
}
// 1、判断等待
// 2、执行业务
// 3、通知
class Data{
private int number = 0;
public synchronized void increment() throws InterruptedException {
// 判断等待
while(number != 0){ //不使用if，使用while，可以防止虚假唤醒
this.wait();
}
// 执行业务
number++;
System.out.println(Thread.currentThread().getName()+"==> "+ number);
// 通知其他线程（唤醒操作）
this.notifyAll();
}
public synchronized void decrement() throws InterruptedException {
while(number == 0){
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"==> "+ number);
// 通知其他线程（唤醒操作）
this.notifyAll();
}
}
【注意事项】：上面代码使用if判断，当有多个线程的时候，会造成虚假唤醒。防止虚假唤醒：将if判断改为while判断。
2.3 管道输入 / 输出流
管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。
管道输入/输出流主要包括了如下4种具体实现：PipedOutputStream、PipedInputStream、PipedReader和PipedWriter，前两种面向字节，而后两种面向字符。
对于Piped类型的流，必须先要进行绑定，也就是调用connect()方法，如果没有将输入/输出流绑定起来，对于该流的访问将会抛出异常。
public class Piped {
public static void main(String[] args) throws Exception {
PipedWriter out = new PipedWriter();
PipedReader in = new PipedReader();
// 将输出流和输入流进行连接，否则在使用时会抛出IOException
out.connect(in);
Thread printThread = new Thread(new Print(in), "PrintThread");
printThread.start();
int receive = 0;
try {
while ((receive = System.in.read()) != -1) {
out.write(receive);
}
} finally {
out.close();
}
}
static class Print implements Runnable {
private PipedReader in;
public Print(PipedReader in) {
this.in = in;
}
public void run() {
int receive = 0;
try {
while ((receive = in.read()) != -1) {
System.out.print((char) receive);
}
} catch (IOException ex) {
}public class PipedIO {
public static void main(String[] args) throws Exception {
PipedWriter out = new PipedWriter();
PipedReader in = new PipedReader();
// 将输出流和输入流进行连接，否则在使用时会抛出IOException
out.connect(in);
Thread printThread = new Thread(new Print(in), "PrintThread");
printThread.start();
int receive = 0;
try {
while ((receive = System.in.read()) != -1) {
out.write(receive);
}
} finally {
out.close();
}
}
static class Print implements Runnable {
private PipedReader in;
public Print(PipedReader in) {
this.in = in;
}
public void run() {
int receive = 0;
try {
while (((receive = in.read()) != -1)) {
System.out.print((char) receive);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.4 ThreadLocal线程本地变量
- ThreadLocal是JDK包提供的，它提供了线程本地变量，也就是如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个本地副本。
- 当多线程操作这个变量的时，实际操作的是自己本地内存里面的变量，从而避免了线程安全问题。
- 创建一个ThreadLocal变量后，每个线程都会复制一个变量到自己的本地内存。
常用方法：
- set方法：将value值放入threadLocals里面
- get方法：从threadLocals中获取变量值
- remove方法：当不需要使用本地变量的时候需要从threadlocals中删除该本地变量。
总结（实现原理）：
- 在每个线程内部都由一个名为threadLocals的成员变量，该变量的类型是HashMap，其中key保存的是我们定义的ThreradLocal变量的this引用，value保存的是我们使用set设置的值。
- 每个线程的本地变量存放在线程自己的内存变量threadLocals中，如果当前线程一直不消亡，那么这些本地变量会一直存在，所以可能会造成内存溢出，因此使用完后需要调用ThreadLocal的remove方法删除对应线程的threadLocals中的本地变量。
ThreadLocal特点
- 不支持继承性：也就是说子线程不可以访问父线程中设置的本地变量。
使用InheritableThreadLocal类可以实现继承性。继承ThreadLocal，主要作用是：子线程可以访问父线程中设置的本地变量
总结（原理）
void createMap(Thread t, T firstValue) {
t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocalMap getMap(Thread t) {
return t.inheritableThreadLocals;
}
- InheritableThreadLocal类通过重写上面两个代码让本地变量保存到了具体线程的inheritableThreadLocals变量里面，那么线程在通过InheritableThreadLocal类实例的set或者get方法设置变量时，就会创建当前线程的inheritableThreadLocals变量。
- 当父线程创建子线程时，构造函数会把父线程中inheritableThreadLocals变量里面的本地变量复制一份保存到子线程的inheritableThreadLocals变量里面。
423
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
