Java并行程序基础(1)，从基础到源码统统帮你搞定

最新推荐文章于 2021-08-11 17:57:40 发布

m0_60732454

最新推荐文章于 2021-08-11 17:57:40 发布

阅读量105

点赞数

分类专栏：程序员文章标签：后端面试 java

本文链接：https://blog.csdn.net/m0_60732454/article/details/119568514

版权

程序员专栏收录该内容

38 篇文章 0 订阅

订阅专栏

4.  ```

    public void Thread.interrupt()              //中断线程

    public void Thread.isInterrupted()          //判断是否被中断

    public static boolean Thread.interrupted()  //判断是否被中断，并清除当前中断状态

    ```

5.  **interrupt()**方法是一个实例方法。它通知目标线程中断，也就是设置**中断标志位**。中断标志位表示当前线程已经被中断了。

6.  **isInterrupted()**方法也是实例方法，它判断当前线程是否有被中断（通过检查中断标志位）

7.  **静态方法interrupted()**也是用来判断当前线程的中断状态，但同时会**清除当前线程的中断标志位状态**。

8.  ```

    public static void main(String[] args) throws InterruptedException {

            Thread t1 = new Thread(()->{

               int i = 1;

               while (true) {

                   if (Thread.currentThread().isInterrupted()) {

                       System.out.println("Interrupt!");

                       break;

                   }

                   System.out.println("I'm working " + i++);

                   Thread.yield();

               }

            });

    

            t1.start();

            Thread.sleep(2000);

            t1.interrupt();

        }

    ```

9.  这看起来跟前面增加标志位的手法非常相似，但是中断的功能更为强劲。比如，如果在循环体中，出现了类似于wait()或者sleep()这样的操作，则只能通过中断来识别了。

线程的睡眠sleep

==========
1. ```
public static native void sleep(long millis) throws InterruptedException;
```
2. 该方法会让当前线程休眠若干时间，会抛出InterruptedException中断异常。InterruptedException不是运行时异常，也就是程序必须捕获并且处理它，当线程在sleep休眠时，如果被中断，这个异常就会发生。
3. ```
public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(()->{

           while (true) {

               if (Thread.currentThread().isInterrupted()) {

                   System.out.println("Interrupt!");

                   break;

               }



               try {

                   Thread.sleep(2000);

               } catch (InterruptedException e) {

                   System.out.println("Interrupted When Sleep");

                   Thread.currentThread().interrupt();

               }

               Thread.yield();

           }

        });



        t1.start();

        Thread.sleep(1000);

        t1.interrupt();

    }
```
4. 如果在sleep的时候，线程被中断，则程序会抛出异常，并进入异常处理。在catch字句里，由于已经捕获了中断，我们可以立即退出线程，但是并没有这么做。因为**也许在这段代码中，还必须进行后续的处理，保障数据的一致性和完整性。**因此，执行了interrupt()方法再次中断自己，置上中断标志位。只有这么做，在检查isInterrupted()，才能发现当前线程已经被中断了。可以试一下将catch的interrupt注释掉进行验证。
5. Thread.sleep()方法由于中断而抛出异常，此时，它会清除中断标记，如果不加处理，那么在下一次循环开始时，就无法不会这个中断，所以在异常处理中，再次设置中断标志位。
等待（wait）和通知（notify）

===================
1. wait和notify不是在Thread类中的方法，而是在Object类中，意味着任何对象都能调用这两个方法。
2. 如果一个线程调用了wait()方法，那么它就会计入object对象的等待队列。这个等待队列中，可能会有多个线程，因为系统运行多个线程同时等待同一个对象。当notify()被调用是，它就会从这个等待队列中，随机选择一个线程，并将其唤醒。但是这个选择不是公平的，并不是先等待的线程会优先被选择，这个选择完全是随机的。
3. notifyAll()方法会唤醒这个等待队列的所有线程。
4. 无论是wait()或者是notify()方法，必须包含在对应的synchronized语句中，无论是wait()或者notify()都需要首先获取目标对象的一个监视器。
5. 而wait()方法执行后，会释放这个监视器，当被重新notify()后，**要做的第一件事不是继续执行后续的代码，而是要尝试重新获取object的监视器。**如果暂时无法获得，线程还必须要等待这个监视器。当监视器顺利获得后，才可以真正意义上的继续执行。
6. wait()方法和sleep()的区别就是，wait会释放对象的锁，而sleep不会释放锁。
挂起（Suspend）和继续执行（resume）

========================
1. 被挂起的线程必须要等到resume操作后，才能继续指定、
2. 但是已经被标注为废弃方法，不推荐使用。因为suspend()在导致线程暂停的同时，并不会去释放任何资源。此时，任何线程想要访问被它暂用的锁，都会备受牵连，导致无法正常运行。直到对应的线程上进行了resume()操作，被挂起的线程才能继续操作。但是如果resume操作在suspend之前就执行了，那么被挂起的线程就很难有机会被继续执行了。
3. 如果想要实现suspend跟resume，可以通过wait跟notify进行使用。
等待线程结束（join）和谦让（yield）

==========================
1. 一个线程的输入可能非常依赖于另外一个或者多个线程的输出，所以，这个线程就需要等待依赖线程执行完毕，才能继续执行。
2. ```
public final void join() throws InterruptedException

public final synchronized void join(long millis) throws InterruptedException 
```
3. 第一个join()方法表示无限等待，它会一直阻塞当前线程，知道目标线程执行完毕。
4. 第二个join()给出了一个最大等待时间，如果超过给定时间目标线程还在执行，当前线程也会因为“等不及”，而继续往下执行。
5. join就是加入的意思，因此一个线程要加入另外一个线程，那么最好的方法就是等着它一起走。
6. ```
public class JoinMain {

    public volatile  static int i = 0;

    public static class AddThread extends Thread {

        @Override

        public void run() {

            for (i = 0; i < 1000000; i++);

        }

    }



    public static void main(String[] args) throws InterruptedException {

        AddThread at = new AddThread();

        at.start();

        at.join();

        System.out.println(i);

    }

}
```
7. 主函数中，如果不用join()等待AddThread,那么得到的i很可能是0或者一个非常小的数字。因为AddThread还没执行完，i的值就已经被输出了。但使用join方法后，表示主线程愿意等待AddThread执行完毕，跟着AddThread一起往前走，所以在join()返回，AddThread已经执行完成，故i总是1000000；
8. join的本质是让调用线程wait()在当前线程对象实例上。
9. ```
if (millis == 0) {

   while (isAlive()) {

      wait(0);

   }

} 
```
10. 可以看到，它调用线程在当前线程对象上进行等待。当执行完成后，被等待的线程会在退出前**调用notifyAll()**通知所有的等待线程继续执行。
11. 因此需要注意，不要在应用程序中，在Thread对象上使用类似wait()或者notify()等方法，因为这很有可能影响系统API的工作，或者被系统API所影响。
```
public static native void yield();

```
```
1. yield()这是个静态方法。一旦执行，它会使当前线程让出CPU。当前线程让出CPU后，还会进行CPU资源的争夺，但是是否能被再次分配到，就不一定了。
volatile与Java内存模型（JMM）

=================================



1.  **Java内存模型都是围绕着原子性，有序性，可见性展开。**

2.  Java使用了一些特殊的操作或者关键字来什么，告诉虚拟机，在这个地方，尤其注意，**不能随意变动优化目标指令**。**volatile**就是其中之一。

3.  volatile：易变的，不稳定的。

4.  当volatile去申明一个变量，就等于告诉虚拟机。这个变量极有可能会被某些线程修改。为了确保这个变量被修改后，应用程序范围内所有线程都能够“看到”。虚拟机就必须采用一些特殊的手段，保证这个变量的可见性等特点。

5.  volatile并不能**替代锁。也无法保证一些符合操作的原子性。volatile无法保证i++原子性操作。**

6.  **volatile能保障数据的可见性和有序性。**

守护线程（Daemon）

=======================



1.  **守护线程**是一种特殊的线程，是系统的守护者，在后台默默地完成一些系统性的服务。比如垃圾回收线程，JIT线程就可以理解为守护线程。

线程的优先级

======



1.  Java使用1~10表示线程优先级。**数字越大优先级越高。******

同步方法以及同步块

=========



1.  **线程同步**

    --------

    

    1.  由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保障数据在方法中被访问时的正确性，在访问时加入锁机制**synchronized，**当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后是否锁即可。但是存在以下问题：

        1.  一个线程持有锁会导致其他所有需要此锁的线程挂起。

        2.  在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题

        3.  如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先倒置，引起性能问题。

    2.  关键字**synchronized**的作用是实现线程间的同步。它的工作是对同步的代码加锁，使得每一次，只能有一个线程进入同步块，从而保证线程间的安全性。

        1.  指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁。

        2.  直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。

        3.  直接作用于静态方法：相当于对当前类加锁，进入同步代码块要获得当前类的锁。

    3.  **synchronized**除了保证**线程同步，**还可以保证线程之间的**可见性和有序性。**从可见性上来说，synchronized可以完全代替volatile，只是使用上没那么方便。就有序性而言，由于synchronized限制每次只有一个线程可以访问同步块，无论同步块内的代码如何被乱序执行，只要保证串行语义一致性，那么执行结果总是一样的。

2.  同步方法

    ----

    

    1.  可以通过private关键字来保证数据对象只能被方法访问，所以只需要针对方法提出一套机制，这套机制就是synchronized关键字。有**synchronized方法**和**synchronized块**

    2.  synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就会独占该锁，直到方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

        1.  缺陷：若将一个大的方法申明为synchronized将会影响效率。

3.  同步块

    ---

    

    1.  同步块：synchronized（obj）{}

给大家分享下我的复习的面试资料

这些面试全部出自大厂面试真题和面试合集当中，小编已经为大家整理完毕（PDF版）

资料获取方式：戳这里前往我的腾讯文档免费下载

第一部分：Java基础-中级-高级

第二部分：开源框架（SSM：Spring+SpringMVC+MyBatis）

第三部分：性能调优（JVM+MySQL+Tomcat）

第四部分：分布式（限流：ZK+Nginx；缓存：Redis+MongoDB+Memcached；通讯：MQ+kafka）

第五部分：微服务（SpringBoot+SpringCloud+Dubbo）

第六部分：其他：并发编程+设计模式+数据结构与算法+网络

进阶学习笔记pdf

都已整理好，需免费下载点击这里即可

Java架构进阶之架构筑基篇（Java基础+并发编程+JVM+MySQL+Tomcat+网络+数据结构与算法）

Java架构进阶之开源框架篇（设计模式+Spring+SpringMVC+MyBatis）

Java架构进阶之分布式架构篇（限流（ZK/Nginx）+缓存（Redis/MongoDB/Memcached）+通讯（MQ/kafka））

Java架构进阶之微服务架构篇（RPC+SpringBoot+SpringCloud+Dubbo+K8s）

28575422964)]

Java架构进阶之分布式架构篇（限流（ZK/Nginx）+缓存（Redis/MongoDB/Memcached）+通讯（MQ/kafka））

[外链图片转存中…(img-u51WuiQr-1628575422965)]

[外链图片转存中…(img-nnMEZDMi-1628575422966)]

[外链图片转存中…(img-qEeeq9Zy-1628575422967)]

Java架构进阶之微服务架构篇（RPC+SpringBoot+SpringCloud+Dubbo+K8s）

[外链图片转存中…(img-Dd0TYpAM-1628575422967)]

[外链图片转存中…(img-TfQVrUhP-1628575422968)]

m0_60732454

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java并行程序基础(1)，从基础到源码统统帮你搞定

4. ``` public void Thread.interrupt() //中断线程 public void Thread.isInterrupted() //判断是否被中断 public static boolean Thread.interrupted() //判断是否被中断，并清除当前中断状态 ```5. **interrupt()**方法是一个实例方法。它通知目标线程中断，也就是设置**中断标志位**。
复制链接

扫一扫