线程基础

最新推荐文章于 2022-01-06 15:30:59 发布

夜班三更敲代码

最新推荐文章于 2022-01-06 15:30:59 发布

阅读量297

点赞数 2

分类专栏：并发编程

本文链接：https://blog.csdn.net/weixin_43889825/article/details/114714836

版权

并发编程专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

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变量里面。

夜班三更敲代码

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
3
评论
线程基础

文章目录1 进程与线程1.1 概念1.2 区别1.3 线程状态及转换1.4 常用的线程方法：1.5 什么是线程安全1.6 Java线程调度1.6.1 协同式调度1.6.2抢占式调度1.7 线程中断2 线程间通信2.1 等待—通知机制2.2 等待—通知范式2.3 管道输入 / 输出流2.4 ThreadLocal线程本地变量1 进程与线程1.1 概念进程：一个在内存中运行的应用程序。它是系统资源分配的基本单位（包括内存地址空间），因此各个进程拥有的内存地址空间相互独立。线程：进程中的一个执行任务（控
复制链接

扫一扫

专栏目录