• Java之线程的概念及方法的学习

    线程创建

    方法一

    直接使用Thread

    1. public class demo {
    2.     public static void main(String[] args) {
    3.         new Thread(){
    4.             @Override
    5.             public void run() {
    6.                 System.out.println(Thread.currentThread().getName());
    7.             }
    8.         }.start();
    9.         System.out.println(Thread.currentThread().getName());
    10.     }
    11. }

    main

    Thread-0

    方法二

    使用Runnable配合Thread将任务与线程创建分开

    1. public class demo {
    2.     public static void main(String[] args) {
    3.         Runnable runnable = new Runnable() {
    4.             @Override
    5.             public void run() {
    6.                 System.out.println(Thread.currentThread().getName());
    7.             }
    8.         };
    9.         //第二个参数是指定线程名字
    10.         new Thread(runnable,"t1").start();
    11.         System.out.println(Thread.currentThread().getName());
    12.     }
    13. }

    main

    t1

    不过Runnable被@FunctionalInterface注解修饰，可以使用lambda表达式化简

    1. public class demo {
    2.     public static void main(String[] args) {
    3.         Runnable runnable = () -> {
    4.             System.out.println(Thread.currentThread().getName());
    5.         }
    6.     //第二个参数是指定线程名字
    7.     new Thread(runnable,"t1").start();
    8. 	System.out.println(Thread.currentThread().getName());
    9. 	}
    10. }

    方法三

    使用FutureTask配合Thread。（FutureTask参数是Callable接口）

    1. public class demo {
    2.     public static void main(String[] args) throws Exception {
    3.         FutureTask task = new FutureTask(new Callable() {
    4.             @Override
    5.             public Integer call() throws Exception {
    6.                 System.out.println(Thread.currentThread().getName());
    7.                 Thread.sleep(1000L);
    8.                 return 1;
    9.             }
    10.         });
    11.         Thread t1 = new Thread(task, "t1");
    12.         t1.start();
    13.         System.out.println(task.get());
    14.     }
    15. }

    t1

    1

    FutureTask实现了RunnableFuture，而RunnableFuture又继承了Runnable与Future接口，Future主要提供了一个get()方法，用于接收子线程的返回值。task.get()在执行时会阻塞，当子线程执行完毕后返回结果才会恢复正常。

    线程执行

    线程在执行过程中是交替执行的，谁先谁后不由我们控制，由操作系统中的任务调度器控制。

    线程的常见方法

    • start()：线程的执行方法，只能说明线程准备好了，并不一定立即执行run方法，要等待CPU时间片分配给他才可以执行。
    • run()：线程被调用后要执行的方法
    • join()：等待线程的运行结束
    • join(long n)：等待线程运行结束的最大等待时间。
    • sleep(long n)：线程休眠时间
    • interrupt()：打断指定线程
    • isInterrupted()：判断线程是否被打断 不会被清除打断标记
    • interrupted()：判断线程是否被打断 会被清楚打断标记

    sleep与yield区别

    调用sleep会将线程状态从Running进入到Timed waiting状态，其他线程可以调用interrupt方法叫醒其他睡眠的线程，线程休眠结束后并不一定立即执行。

    yield会将当前线程状态从Running到Runnable状态，然后调度执行其他线程。但是具体执行哪个线程还是由操作系统决定

    sleep与wait区别

    sleep并不会释放锁，而wait会释放锁对象

    sleep时Thread方法，wait是Object方法，并且wait需要配合synchronized使用

    park与unpark

    与wait与notify相似，都是让线程休眠。但是是LockSupport中的方法。

    LocakSupport.park()，使作用域中的线程进入休眠。

    LockSupport.unpart(线程对象)，唤醒线程。

    unpark可以在线程park之前进行执行，使未park的线程在执行park后起不到休眠的作用。

    原理

    park会将线程中的某个属性值修改为0，如果本身就为0时执行park会使线程休眠。如果本身为1，则修改为0不会休眠。

    unpark会将线程中属性修改为1，多次调用unpark也只是设置为1。如果线程本身就在休眠，那么会将其唤醒不修改其属性值还是为0，如果线程本身就在执行中，那么会将其属性修改为1。

    查看进程的方法

    windows

    • 任务管理器可以查看进程和线程数，也可以用来杀死进程
    • tasklist 查看进程 筛选进程 tasklist | findstr 程序名
    • taskkill 杀死进程

    linux

    • ps -fe 查看所有进程 筛选 ps -fe | grep 程序名
    • ps -fT -p 查看某个进程（PID）的所有线程
    • kill杀死进程
    • top 按大写 H 切换是否显示线程
    • top -H -p 查看某个进程（PID）的所有线程

    Java

    • jps 命令查看所有 Java 进程
    • jstack 查看某个 Java 进程（PID）的所有线程状态
    • jconsole 来查看某个 Java 进程中线程的运行情况（图形界面）

    线程运行原理

    栈与栈帧

    栈内存是给线程使用的，每启动一个线程JVM都会为其分配一个栈内存

    每个栈由多个栈帧组成，对应每次方法调用所占用的内存。每个栈只有一个活动栈帧，对应正在运行的方法。

    线程上下文

    因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码

    • 线程的 cpu 时间片用完
    • 垃圾回收
    • 有更高优先级的线程需要运行
    • 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

    以上前三种是被动停止，最后一种属于主动停止自己的线程。

    线程在进行切换时会记录停止线程的当前状态，方便恢复执行时，从停止地方接着执行。

    防止CPU占用率100%

    在没有CPU计算时，不要让while(true)空转浪费CPU，这时可以通过sleep或yield让出CPU去执行其给程序。（在单核CPU如果存在while(true)会占用率为100%）

    interrupt打断线程

    阻塞状态下

    如果子线程在阻塞状态下如sleep、wait、join时，被interrupt方法打断会抛出异常。sleep被interrupt打断后，会清除打断标记！

    阻塞状态下也会被标记为true，但是退出线程后会被清除为false。

    1. public class demo {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         Thread t1 = new Thread(()->{
    4.             try {
    5.                 Thread.sleep(1000L);
    6.             } catch (InterruptedException e) {
    7.                 e.printStackTrace();
    8.             }
    9.         });
    10.         t1.start();
    11.         //这里调用interrupt后子线程执行sleep方法，正常打断，抛出异常，结束线程
    12.         t1.interrupt();
    13.         System.out.println(t1.isInterrupted());
    14.     	//主线程休眠让子线程执行sleep
    15.         Thread.sleep(100L);
    16.         //线程结束，清除标记
    17.         System.out.println(t1.isInterrupted());
    18.     }
    19. }

    true

    java.lang.InterruptedException: sleep interrupted

    at java.lang.Thread.sleep(Native Method)

    at demo.lambda$main$0(demo.java:5)

    at java.lang.Thread.run(Thread.java:745)

    false

    正常状态下

    如果子线程正在执行，被其他线程打断的话，由子线程自身决定自己是否停止执行

    1. public class demo {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         Thread t1 = new Thread(()->{
    4.            while (true){
    5.                //如果正常状态下被打断会被标记为true
    6.                if (Thread.currentThread().isInterrupted()){
    7.                    System.out.println("我被打断了");
    8.                    break;
    9.                }
    10.            }
    11.         });
    12.         t1.start();
    13.         Thread.sleep(100L);
    14.         t1.interrupt();
    15.     }
    16. }

    interrupt、interrupted、isInterrupted

    • interrupt：标记调用者打断标记为true。
    • interrupted：获取当前线程的中断状态、并清除。哪个线程中执行就是获取哪个线程
    • isInterrupted：获取对象线程的中断状态，但不会清除

    两阶段终止模式（设计模式）

    打断标记法实现

    指的是线程1终止线程2的进行

    比如说一个后台监控系统，一个线程while循环持续监控，当不需要监控时，打断线程即可，如果在休眠期期间被打断，那么抓住异常手动设置打断标记，如果是执行监控时被打断，等到下一次判断时就会退出循环。

    1. public class TwoPhaseTerminationTest {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         TwoPhaseTermination twoPhaseTermination = new TwoPhaseTermination();
    4.         twoPhaseTermination.start();
    5.         Thread.sleep(3000);
    6.         twoPhaseTermination.stop();
    7.     }
    8. }
    9.  
    10. class TwoPhaseTermination{
    11.     private Thread monitor;
    12.  
    13.     public void start(){
    14.         monitor = new Thread(()->{
    15.             System.out.println("开始监控");
    16.             Thread thread = Thread.currentThread();
    17.             while (true){
    18.                 if (thread.isInterrupted()){
    19.                     System.out.println("结束前终止操作");
    20.                     break;
    21.                 }
    22.                 try {
    23.                     Thread.sleep(2000);
    24.                     System.out.println("进行监控");
    25.                 } catch (InterruptedException e) {
    26.                     e.printStackTrace();
    27.                     thread.interrupt();
    28.                 }
    29.             }
    30.         });
    31.  
    32.         monitor.start();
    33.     }
    34.  
    35.     public void stop(){
    36.         System.out.println("停止监控");
    37.         monitor.interrupt();
    38.     }
    39. }

    开始监控

    进行监控

    停止监控

    结束前终止操作

    java.lang.InterruptedException: sleep interrupted

    at java.lang.Thread.sleep(Native Method)

    at TwoPhaseTermination.lambda$start$0(TwoPhaseTerminationTest.java:23)

    at java.lang.Thread.run(Thread.java:745)

    volatile实现

    1. public class TwoPhaseTerminationTest {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         TwoPhaseTermination twoPhaseTermination = new TwoPhaseTermination();
    4.         twoPhaseTermination.start();
    5.         Thread.sleep(3000);
    6.         twoPhaseTermination.stop();
    7.     }
    8. }
    9.  
    10. class TwoPhaseTermination{
    11.     private Thread monitor;
    12.  
    13.     private volatile boolean stop = false;
    14.  
    15.     private boolean starting = false;
    16.  
    17.     public void start(){
    18.         //防止主线程多次使用start()方法来创建多个相同的监控线程。
    19.         synchronized(this){
    20.             if(starting){
    21.                 return;
    22.             }
    23.             starting = true;
    24.         }
    25.         monitor = new Thread(()->{
    26.             System.out.println("开始监控");
    27.             Thread thread = Thread.currentThread();
    28.             while (true){
    29.                 if (stop){
    30.                     System.out.println("结束前终止操作");
    31.                     break;
    32.                 }
    33.                 try {
    34.                     Thread.sleep(2000);
    35.                     System.out.println("进行监控");
    36.                 } catch (InterruptedException e) {
    37.                     e.printStackTrace();
    38.                 }
    39.             }
    40.         });
    41.  
    42.         monitor.start();
    43.     }
    44.  
    45.     public void stop(){
    46.         System.out.println("停止监控");
    47.         //设置为false后break结束循环
    48.         stop = true;
    49.         //如果线程休眠时间较长，但是需要即使打断的话也可以使用interrupt方法来打断。
    50.         monitor.interrupt();
    51.     }
    52. }

    守护线程

    通常情况下，当Java中所有线程结束后，程序才会结束，但是如果存在守护线程，当其他非守护线程结束后，即使守护线程还未执行结束，程序也会停止。

    1. public class demo {
    2.     public static void main(String[] args) {
    3.         new Thread(()->{
    4.             try {
    5.                 Thread.sleep(10000);
    6.                 System.out.println("线程结束");
    7.             } catch (InterruptedException e) {
    8.                 e.printStackTrace();
    9.             }
    10.         }).start();
    11.         System.out.println("主线程结束");
    12.     }
    13. }

    主线程结束

    线程结束

    以上是主线程结束后程序等待子线程结束后才会停止。那么将子线程设置为守护线程测试

    1. public class demo {
    2.     public static void main(String[] args) {
    3.         Thread t1 = new Thread(() -> {
    4.             try {
    5.                 Thread.sleep(10000);
    6.                 System.out.println("线程结束");
    7.             } catch (InterruptedException e) {
    8.                 e.printStackTrace();
    9.             }
    10.         });
    11.         t1.setDaemon(true);
    12.         t1.start();
    13.         System.out.println("主线程结束");
    14.     }
    15. }

    主线程结束

    此时程序并没有等待子线程的结束而是直接停止了运行。

    线程运行状态

    五种状态

    从操作系统上来讲。线程一共存在五种运行状态，分别为初始状态、可运行状态、运行状态、阻塞状态、终止状态

    1. 初始化状态：new了但没start，并未与操作系统中的线程相关联。
    2. 可运行状态：start了，但是没有执行，CPU时间片没有分配到
    3. 运行状态：获取了CPU时间片可以执行线程中的代码。
    4. 阻塞状态：执行了阻塞API，如读取文件等IO操作，测试线程进入阻塞状态，并且调度器不会为阻塞状态下的线程分配时间片，直到阻塞结束后由操作系统将其转化为可运行状态才会为其分配时间片。
    5. 终止状态：线程执行结束，声明周期结束。

    六种状态

    从java层次来看，线程通过枚举一共有六种状态。

    1. NEW：对应操作系统层次中的初始化状态
    2. RUNNABLE：对应操作系统中的【可运行状态】【运行状态】【阻塞状态】因为在Java中，并不能判断出自己执行的是阻塞操作，因此将阻塞状态也归结为RUNNABLE。
    3. TERMINATED：线程运行结束。
    4. TIMED_WAITING：有时限的等待如sleep
    5. WAITING：无时限的等待如join
    6. BLOCKED：其他线程拿到了同步锁对象，当其他线程再去拿就会进去BLOCKED状态。

    线程变量的安全问题

    成员变量与静态变量

    对于成员变量与静态变量，如果没有共享则线程安全。如果共享则要看他们状态是否会发生改变。

    如果是只读下，线程安全，涉及到读写则线程不安全。

    局部变量

    局部变量是线程安全的，但是局部变量引用的对象不一定线程安全，取决于被引用的对象有没有逃离作用范围。

    1. public class demo2 {
    2.     private static final int THREAD_NUM = 2;
    3.     private static final int FOR_NUM = 200;
    4.  
    5.     public static void main(String[] args) {
    6.         ThreadUnsafe threadUnsafe = new ThreadUnsafe();
    7.         for (int i = 0; i < THREAD_NUM; i++) {
    8.             new Thread(()->{
    9.                 threadUnsafe.method1(FOR_NUM);
    10.             },"t"+i).start();
    11.         }
    12.     }
    13. }
    14.  
    15. class ThreadUnsafe {
    16.     List list = new ArrayList<>();
    17.     public void method1(int num) {
    18.         for (int i = 0; i < num; i++) {
    19.             method2();
    20.             method3();
    21.         }
    22.     }
    23.  
    24.     public void method2(){
    25.         list.add("1");
    26.     }
    27.  
    28.     public void method3(){
    29.         list.remove(0);
    30.     }
    31. }

    Exception in thread "t0" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0

    at java.util.ArrayList.rangeCheck(ArrayList.java:653)

    at java.util.ArrayList.remove(ArrayList.java:492)

    at ThreadUnsafe.method3(demo2.java:32)

    at ThreadUnsafe.method1(demo2.java:23)

    at demo2.lambda$main$0(demo2.java:12)

    at java.lang.Thread.run(Thread.java:745)

    至于为啥会报错，应该看add源码

    重点在于size++。字节码文件add操作不是一个原子操作。

    t1线程抢占CPU时间片后，对list进行size++，加完后要要返回size值，比如说初始是0，进行size++后应该返回1但是还未进行返回，线程t2拿到CPU时间片，拿到的size值还为0，进行size++后返回1，t1恢复还是返回1但实际上size应该为2。因此remove两次后就会报错。由此可以总结问题所在是list变量被线程共享了，只需要将list变为局部变量即可解决这个问题

    1. class ThreadSafe {
    2.     public void method1(int num) {
    3.         List list = new ArrayList<>();
    4.         for (int i = 0; i < num; i++) {
    5.             method2(list);
    6.             method3(list);
    7.         }
    8.     }
    9.  
    10.     public void method2(List list) {
    11.         list.add("1");
    12.     }
    13.  
    14.     public void method3(List list) {
    15.         list.remove(0);
    16.     }
    17. }

    这样并不会报错。因为各自的线程内存在各自的list。

    子类重写父类方法可能会导致线程不安全

    1. import java.util.ArrayList;
    2. import java.util.List;
    3.  
    4. public class demo2 {
    5.     private static final int THREAD_NUM = 2;
    6.     private static final int FOR_NUM = 200;
    7.  
    8.     public static void main(String[] args) {
    9.         ThreadSafeSubclass threadSafeSubclass = new ThreadSafeSubclass();
    10.         for (int i = 0; i < THREAD_NUM; i++) {
    11.             new Thread(() -> {
    12.                 threadSafeSubclass.method1(FOR_NUM);
    13.             }, "thread" + i).start();
    14.         }
    15.     }
    16. }
    17.  
    18. class ThreadUnsafe {
    19.     List list = new ArrayList<>();
    20.  
    21.     public void method1(int num) {
    22.         for (int i = 0; i < num; i++) {
    23.             method2();
    24.             method3();
    25.         }
    26.     }
    27.  
    28.     public void method2() {
    29.         list.add("1");
    30.     }
    31.  
    32.     public void method3() {
    33.         list.remove(0);
    34.     }
    35. }
    36.  
    37. class ThreadSafe {
    38.     public void method1(int num) {
    39.         List list = new ArrayList<>();
    40.         for (int i = 0; i < num; i++) {
    41.             method2(list);
    42.             method3(list);
    43.         }
    44.     }
    45.  
    46.     public void method2(List list) {
    47. //        list.add("1");
    48.         System.out.println(Thread.currentThread().getName()+":1");
    49.     }
    50.  
    51.     public void method3(List list) {
    52.         list.remove(0);
    53.     }
    54. }
    55.  
    56. class ThreadSafeSubclass extends ThreadSafe{
    57.     @Override
    58.     public void method3(List list) {
    59.         new Thread(()->{
    60. //            list.remove(0);
    61.             System.out.println(Thread.currentThread().getName()+":2");
    62.         }).start();
    63.     }
    64. }

    结果可知，没办法保证方法的执行顺序。

    线程安全类

    String类、Integer、StringBuffer、Random、JUC包下的所有方法等都是线程安全的。

    他们单个方法都是线程安全的（因为加入了synchronized关键字），但是当他们组合使用是就不是线程安全的。如下图。

    1. HashTable hashTable = new HashTable();
    2. if(hashTable.get("key") == null){
    3.     hashTable.put("key",value);
    4. }

  • 相关阅读:
    如何灵活运用量化交易接口的优势取长补短？
    mac os 通过vs code连接远程服务器 （ssh方法）
    3个iPhone设置让你成为“人类高质量iPhone用户”
    C++虚继承原理与类布局分析
    多视图聚类的论文阅读（一）
    基于Java毕业设计高校共享机房管理系统的设计与实现源码+系统+mysql+lw文档+部署软件
    秋招每日一题T3——设计循环双端队列
    本地Image Registry Harbor安装
    Abnova丨5-甲基胞嘧啶多克隆抗体中英文说明
    【题解】同济线代习题一.8.4
  • 原文地址：https://blog.csdn.net/zmbwcx/article/details/134484282