【并发编程之美】线程简介与线程的简单操作

末蓝、 2021-06-30 12:59 362阅读 0赞

声明：博客全部参考《JAVA并发编程之美》

什么是线程

线程是进程中的一个实体，本身不独立存在。它是代码再数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，线程是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的资源。
在这里插入图片描述
点击[JAVA运行时数据区域][JAVA]，查看java的内存分配。

线程的创建与执行

线程的创建有三种方式，其实可以分为两种类型：

  1. 没有返回值的：
    1.1 继承Thread类并重写run的方法
    这个方法的好处是，再run()方法内获取当前线程直接使用this就可以了，无需使用Thread.currentThread()方法
    不好的地方是，继承了这个类之后，就不能再去继承别的类了
    1.2 实现Runnable接口的run方法
    没有继承Thread类的限制，这样就可以实现多个接口

  2. 有返回值的：使用FutureTask方法
    使用FutureTask方法，再main函数内首先创建了一个FutrueTask对象，然后使用创建的FutrueTask对象作为任务创建了一个线程并且启动她，最后通过futureTask.get()等待任务执行完毕并返回结果

    package com.banana.chapter01.demo1_2;

    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;

    public class ThreadTest { 

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

    / 第一种 实现Runnable接口的run方法 // 创建线程 MyThread thread = new MyThread(); // 启动线程 thread.run(); /

    / 第二种 继承Thread类并重写run的方法 RunableTask task = new RunableTask(); new Thread(task).start(); new Thread(task).start(); /

  1. /* 第三种 使用FutureTask方法 //创建异步任务 FutureTask<String> futureTask=new FutureTask<>(new CallerTask()); //启动线程 new Thread(futureTask).start(); try { //等待任务执行完毕，并且返回结果 String result = futureTask.get(); System.out.println(result); }catch (ExecutionException e){ e.printStackTrace(); } */
  3.     }
  4. /* 第一种 public static class MyThread extends Thread { @Override public void run() { System.out.println("I am a child thread"); } } */
  6. /* 第二种 public static class RunableTask extends Thread { @Override public void run() { System.out.println("I am a child thread"); } } */
  8. /* 第三种 public static class CallerTask implements Callable<String> { @Override public String call() throws Exception { return "hello"; } } */
  10. }

线程的通知和等待

这里就要讲两个方法，一个是wait()，另一个是notify()

wait()

调用wait方法时，该调用线程会被阻塞挂起，直到发生以下两个情况才会返回：

  1. 其他线程调用了该共享对象的notify()或者notifyAll()方法；
  2. 其他线程调用了该线程的interrupt()方法，该线程抛出InterrupteException异常返回。

wait(long timeout)

加了一个超时参数，默认的wait()其实就是调用的wait(0)，如果传入了负数则就会抛出IllegalArgumentException异常。

wait(long timeout, int nanos)

内部调用的是wait(long timeout)，会根据nanos的值再去看wait方法如何执行。

notify()

调用notify方法后，会唤醒一个在该共享变量上调用wait系列方法后被挂起的线程。一个共享变量上可能会有多个线程在等待，具体唤醒哪个等待线程是随机的。

notifyAll()

notifyAll()会唤醒所有在该共享变量上由于调用wait系列方法而被挂起的线程。

等待线程执行终止的join方法

join方法实现的就是等待线程执行完毕再向下执行，有的时候多个线程加载资源，需要等待全部完成后再汇总处理就会用得到

  1. package com.banana.chapter01.demo1_4;
  3. public class ThreadJoinTest { 
  5.     public static void main(String[] args) throws InterruptedException { 
  6.         Thread threadOne = new Thread(new Runnable() { 
  7.             @Override
  8.             public void run() { 
  9.                 try { 
  10.                     Thread.sleep(1000);
  11.                 } catch (InterruptedException e) { 
  12.                     e.printStackTrace();
  13.                 }
  14.                 System.out.println("child threadOne over!");
  15.             }
  16.         });
  18.         Thread threadTwo = new Thread(new Runnable() { 
  19.             @Override
  20.             public void run() { 
  21.                 try { 
  22.                     Thread.sleep(1000);
  23.                 } catch (InterruptedException e) { 
  24.                     e.printStackTrace();
  25.                 }
  26.                 System.out.println("child threadTwo over!");
  27.             }
  28.         });
  30.         //启动子线程
  31.         threadOne.start();
  32.         threadTwo.start();
  34.         System.out.println("wait all child thread over!");
  36.         //等待子线程执行完毕，返回
  37.         threadOne.join();
  38.         threadTwo.join();
  40.         System.out.println("all child thread over!");
  42.     }
  44. }

打印结果

  1. wait all child thread over!
  2. child threadOne over!
  3. child threadTwo over!
  4. all child thread over!

让线程睡眠的sleep方法

sleep方法会暂时让出指定时间的执行权，也就是在这期间不参与CPU的调度，但是该线程所拥有的资源监视器资源，比如锁还是持有不让出的。

  1. package com.banana.chapter01.demo1_5;
  3. public class ThreadJoinTest { 
  5.     public static void main(String[] args) throws InterruptedException { 
  7.         //创建线程
  8.         Thread thread = new Thread(new Runnable() { 
  9.             @Override
  10.             public void run() { 
  11.                 try{ 
  12.                     System.out.println("child thread is in sleep");
  13.                     Thread.sleep(10000);
  14.                     System.out.println("child thread is in awaked");
  15.                 } catch (InterruptedException e) { 
  16.                     e.printStackTrace();
  17.                 }
  18.             }
  19.         });
  21.         //启动线程
  22.         thread.start();
  24.         //主线程休眠2s
  25.         Thread.sleep(2000);
  27.         //主线程中断子线程
  28.         thread.interrupt();
  30.         //因为现在子线程处于休眠状态，所以此时中断子线程就会报错
  32.     }
  34. }

打印结果

  1. child thread is in sleep
  2. java.lang.InterruptedException: sleep interrupted
  3.     at java.lang.Thread.sleep(Native Method)
  4.     at com.banana.chapter01.demo1_5.ThreadJoinTest$1.run(ThreadJoinTest.java:13)
  5.     at java.lang.Thread.run(Thread.java:745)

因为此时子线程处于休眠状态，所以在这个时候执行中断操作就会报错。

让出CPU执行权的yield方法

当一个线程执行yield方法的时候，当前线程就会让出自己的CPU使用权，然后处于就绪状态，线程调度器会从线程就绪队列里面获取一个线程优先级最高的线程，也有可能就会调度到刚刚让出CPU的那个线程来获取CPU执行权。

  1. package com.banana.chapter01.demo1_6;
  3. public class YieldTest implements Runnable { 
  5.     public static void main(String[] args) { 
  6.         new YieldTest();
  7.         new YieldTest();
  8.         new YieldTest();
  9.     }
  11.     YieldTest() { 
  12.         //创建并启动线程
  13.         Thread t = new Thread(this);
  14.         t.start();
  15.     }
  17.     @Override
  18.     public void run() { 
  19.         for (int i = 0; i < 5; i++) { 
  20.             //当i=0的时候让出CPU执行权，放弃时间片，进行下一轮调度
  21.             if ((i % 5) == 0) { 
  22.                 System.out.println(Thread.currentThread() + "yield cpu...");
  24.                 //当前线程让出CPU执行权，放弃时间片，进行下一轮调度
  25.                 Thread.yield();
  26.             }
  27.         }
  28.         System.out.println(Thread.currentThread()+ " is over");
  29.     }
  32. }

打印结果

  1. Thread[Thread-1,5,main]yield cpu...
  2. Thread[Thread-2,5,main]yield cpu...
  3. Thread[Thread-1,5,main] is over
  4. Thread[Thread-0,5,main]yield cpu...
  5. Thread[Thread-2,5,main] is over
  6. Thread[Thread-0,5,main] is over

sleep和yield的方法区别

当线程调用sleep方法时调用线程会被阻塞挂起指定的时间，在这期间线程调度器不会去调度该线程。而调用yield方法时，线程只是让出自己剩余的时间片，并没有被阻塞挂起，而是处于就绪状态，线程调度器下一次调度时就可能调度到当前线程执行。

线程中断

线程中断是一种线程间的协作模式，通过设置线程的中断标志并不能直接终止该线程的执行，而是被中断的线程根据中断状态自行处理。

void interrupt()

中断线程的方法。

boolean isInterrupted()

检测当前线程是否被中断，如果是返回true，否则返回false。

boolean interrupted()

检测当前线程是否被中断，如果是返回true，否则返回false。和isInterrupted()方法不同的事，这个方法如果发现线程被中断的话，就会把中断标志清楚，并且这是一个static方法。

根据中断标志判断线程是否终止

  1. package com.banana.chapter01.demo1_7;
  3. public class ThreadTest { 
  5.     public static void main(String[] args) throws InterruptedException { 
  6.         Thread thread = new Thread(new Runnable() { 
  7.             @Override
  8.             public void run() { 
  9.                 //如果当前线程被中断则退出循环
  10.                 while(!Thread.currentThread().isInterrupted()){ 
  11.                     System.out.println(Thread.currentThread()+" hello");
  12.                 }
  13.             }
  14.         });
  16.         //启动子线程
  17.         thread.start();
  19.         //主线程休眠1s，以便中断前让子进程输出
  20.         Thread.sleep(1000);
  22.         //中断子线程
  23.         System.out.println("main thread interrupt thread");
  24.         thread.interrupt();
  26.         //等待子线程执行完毕
  27.         thread.join();
  28.         System.out.println("main is over");
  30.     }
  32. }

执行结果
Thread[Thread-0,5,main] hello
Thread[Thread-0,5,main] hello
…
Thread[Thread-0,5,main] hello
Thread[Thread-0,5,main] hello
main thread interrupt thread
Thread[Thread-0,5,main] hello
main is over
由于线程在运行中被中断，然后判断了线程是否被中断，接着退出了子线程，主线程结束。

interrupted()和isInterrupted()的不同

  1. package com.banana.chapter01.demo1_7;
  3. public class ThreadTest3 { 
  5.     public static void main(String[] args) throws InterruptedException { 
  6.         Thread threadOne = new Thread(new Runnable() { 
  7.             @Override
  8.             public void run() { 
  9.                 for (; ; ) { 
  10.                 }
  11.             }
  12.         });
  14.         threadOne.start();
  16.         threadOne.interrupt();
  18.         //获取中断标志
  19.         System.out.println("isInterrupt: " + threadOne.isInterrupted());
  20.         //获取中断标志并重置
  21.         System.out.println("isInterrupt: " + threadOne.interrupted());//这里获取的是主线程的interrupt状态
  22.         //获取中断标志并重置
  23.         System.out.println("isInterrupt: " + Thread.interrupted());
  24.         //获取中断标志
  25.         System.out.println("isInterrupt: " + threadOne.isInterrupted());
  26.         threadOne.join();
  27.         System.out.println("main thread is over");
  28.     }
  30. }

打印结果
isInterrupt: true
isInterrupt: false
isInterrupt: false
isInterrupt: true
第一个：true，线程被中断，中断标志为true
第二个：false，因为是获取的当前线程，当前线程是主线程，所以虽然是调用的threadOne的方法，但实际上依旧是获取的当前线程，当前线程没有被中断，所以此处是false
第三个：false，此处是主线程，和第二个一样
第四个：true，获取线程是否被中断，可以得知线程是被中断了的
最后没有输出main thread is over，是因为当前的进程一直处于运行状态，所以没有继续向下运行

线程上下文切换

在多线程编程中，线程个数一般都大于CPU个数，而每个CPU同一时刻只能被一个线程使用，为了让用户感觉多个线程是在同时执行的，CPU资源的分配采用了时间片轮转的策略，也就是给每个线程分配一个时间片，线程在时间片内占用CPU执行任务。当前线程使用完时间片后，就会处于就绪状态并让出CPU让其他线程占用，这就是上下文切换，从当前线程的上下文切换到了其他线程。那么就有一个问题，让出CPU的线程等下次轮到自己占有CPU时如何知道自己之前运行到哪里了？所以在切换线程上下文时需要保存当前线程的执行现场，当再次执行时根据保存的执行现场信息恢复执行现场。

线程上下文切换时机有：当前线程的CPU时间片使用完处于就绪状态时，当前线程被其他线程中断时。

线程死锁

死锁是指两个或两个以上的线程在执行过程中，因争夺资源而造成的互相等待的现象，在无外力作用的情况下，这些线程会一直相互等待而无法继续运行下去。
在这里插入图片描述
线程A持有了资源2，线程B持有了资源1，线程A请求资源1，线程B请求资源2，他们都不释放自己所拥有的，所以就造成了死锁。
产生死锁的四个条件：

  1. 互斥条件
  2. 请求并持有条件
  3. 不可剥夺条件

  4. 环路等待条件

    package com.banana.chapter01.demo1_9;

    public class DeadLockTest01 { 

    1. //创建资源
    2. private static Object resourceA = new Object();
    3. private static Object resourceB = new Object();
    5. public static void main(String[] args) { 
    6.     //创建线程A
    7.     Thread threadA = new Thread(new Runnable() { 
    8.         @Override
    9.         public void run() { 
    10.             synchronized (resourceA) { 
    11.                 System.out.println(Thread.currentThread() + "get ResourceA");
    12.                 try { 
    13.                     Thread.sleep(1000);
    14.                 } catch (InterruptedException e) { 
    15.                     e.printStackTrace();
    16.                 }
    17.                 System.out.println(Thread.currentThread() + "waiting get ResourceB");
    18.                 synchronized (resourceB) { 
    19.                     System.out.println(Thread.currentThread() + "get ResourceB");
    20.                 }
    21.             }
    22.         }
    23.     });
    24.     //创建线程B
    25.     Thread threadB = new Thread(new Runnable() { 
    26.         @Override
    27.         public void run() { 
    28.             synchronized (resourceB) { 
    29.                 System.out.println(Thread.currentThread() + "get ResourceB");
    30.                 try { 
    31.                     Thread.sleep(1000);
    32.                 } catch (InterruptedException e) { 
    33.                     e.printStackTrace();
    34.                 }
    35.                 System.out.println(Thread.currentThread() + "waiting get ResourceA");
    36.                 synchronized (resourceA) { 
    37.                     System.out.println(Thread.currentThread() + "get ResourceA");
    38.                 }
    39.             }
    40.         }
    41.     });
  1.         //启动线程
  2.         threadA.start();
  3.         threadB.start();
  4.     }
  6. }

运行结果
Thread[Thread-1,5,main]get ResourceB
Thread[Thread-0,5,main]get ResourceA
Thread[Thread-0,5,main]waiting get ResourceB
Thread[Thread-1,5,main]waiting get ResourceA

此时这个进程还处于运行状态，所以可以体现出目前线程是处于一个死锁的状态，不能向下运行。

守护线程和用户线程

什么是守护线程

Java中的线程分为两类，分别为daemon线程（守护线程）和user线程（用户线程）。在JVM启动时会调用main函数，main函数所在的线程就是一个用户线程，其实在JVM内部同时还启动了好多守护线程，比如垃圾回收线程。那么守护线程和用户线程有什么区别呢？区别之一是当最后一个非守护线程结束时，JVM会正常退出，而不管当前是否有守护线程，也就是说守护线程是否结束并不影响IVM的退出。言外之意，只要有一个用户线程还没结束，正常情况下JVM就不会退出。

守护线程的创建

和普通的线程创建一样，加一句thread.setDaemon(true)即设置线程为守护线程。

  1. package com.banana.chapter01.demo1_10;
  3. public class ThreadTest { 
  5.     public static void main(String[] args) { 
  7.         Thread thread = new Thread(new Runnable() { 
  8.             @Override
  9.             public void run() { 
  10.                 for (; ; ) { 
  11.                 }
  12.             }
  13.         });
  15.         thread.setDaemon(true);
  17.         //启动子线程
  18.         thread.start();
  20.         System.out.println("main thread is over");
  22.     }
  24. }

运行结果
main thread is over

设置了线程为守护线程之后，主线程运行不会管这个守护线程是否正在运行，运行完会直接退出。

总结：如果你希望主线程结束后JVM进程马上结束，那么在创建线程时可以将其设置为守护线程，如果你希望在主线车工结束后子线程继续工作，等子线程结束后再让JVM进程结束，那么就将子线程设置为用户线程。

发表评论

表情：
评论列表 （有 0 条评论，362人围观）

还没有评论，来说两句吧...

相关阅读

    相关 并发编程之线程和线程池

    1. 线程 线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。 线程是调度CPU资源的最小单位，线程模型分为K

    向右看齐向右看齐/ 0 赞/ 466 阅读

    相关 并发编程之——线程基础

    一、线程和进程   进程：程序运行资源分配的最小单位，进程内部有多个线程，会共享这个进程的资源。 线程：CPU调度的最小单位，必须依赖进程而存在，线程之间共享进程的资

    末蓝、末蓝、/ 0 赞/ 318 阅读

    相关 并发编程之线程池

    为什么使用线程池 有时候，系统需要处理非常多的执行时间很短的请求，如果每一个请求都开启一个新线程的话，系统就要不断的进行线程的创建和销毁，有时花在创建和销毁线程上的时间会

    ゞ 浴缸里的玫瑰ゞ 浴缸里的玫瑰/ 0 赞/ 438 阅读