基本概念

线程与进程

线程：系统资源分配的最小单位，使用独立的数据空间
进程：程序执行的最小单位，线程共享进程的数据空间

进程与线程的一个简单解释 - 阮一峰的网络日志

并发与并行

并发:同一时间段，多个任务都在执行 (单位时间内不一定同时执行)；
并行:同单位时间内多个任务同时执行

并发的好处与坏处

JVM的内存模型与JMM（Java Memory Model）

JMM定义了程序中变量的访问规则。所有的共享变量都存储在主内存中，每个线程有自己的工作内存，工作内存保存的是共享变量的副本。线程对变量的读写操作必须在自己的工作内存中进行，而不能直接读写主内存中的变量
image.png

线程的基本操作

线程的创建方式

  1. 实现Runnable接口
  1. // 创建任务
  2. Runnable task = () -> {
  3.   ...
  4. }
  5. // 运行任务
  6. new Thread(task).start()
  1. 继承Thread类
  1. class Task extends Thread{
  2.   public void run(){
  3.     ...
  4.   }
  5. }
  7. Task task = new Taskl();
  8. task.start();

线程的状态(Thread.State)


from 《Java 并发编程艺术》

Thread.run() 和 Thread.start()的区别

  • Thread.run()
  1. public void run() {
  2.         if (target != null) {
  3.             // target的类型是Runnable,这里调用的是Runnable的run方法
  4.             target.run();
  5.         }
  6.     }
  • Thread.start()
  1. public synchronized void start() {
  2.        // 如果线程的状态不是0(not yet started),则会抛出运行异常,即一个线程不能够多次调用start方法
  3.         if (threadStatus != 0)
  4.             throw new IllegalThreadStateException();
  5.         group.add(this);
  7.         boolean started = false;
  8.         try {
  9.             start0();
  10.             started = true;
  11.         } finally {
  12.             try {
  13.                 if (!started) {
  14.                     group.threadStartFailed(this);
  15.                 }
  16.             } catch (Throwable ignore) {
  17.                 /* do nothing. If start0 threw a Throwable then
  18.                   it will be passed up the call stack */
  19.             }
  20.         }
  21.     }

直接调用run方法是串行执行对象的run方法体.调用start方法是开启一个线程并使得线程处于RUNNABLE状态,当分配到时间片后就会执行run方法体.

wait(等待) and notify(通知)

  1. @Test
  2.     public void waitAndNotify() {
  3.         final String flag = "";
  4.         // 线程1等待直到被唤醒后打印消息
  5.         Runnable task1 = () -> {
  6.             try {
  7.                 // 去掉synchronized,抛出java.lang.IllegalMonitorStateException
  8.                 synchronized (flag) {
  9.                     flag.wait();
  10.                 }
  11.                 System.out.println("I am notified!!");
  12.             } catch (InterruptedException e) {
  13.                 e.printStackTrace();
  14.             }
  15.         };
  17.         // 线程2等待2s后唤起线程1
  18.         Runnable task2 = () -> {
  19.             try {
  20.                 Thread.sleep(2000);
  21.                 // 去掉synchronized,抛出java.lang.IllegalMonitorStateException
  22.                 synchronized (flag) {
  23.                     flag.notify();
  24.                 }
  25.             } catch (InterruptedException e) {
  26.                 e.printStackTrace();
  27.             }
  28.         };
  29.         // 启动
  30.         Thread t1 = new Thread(task1);
  31.         Thread t2 = new Thread(task2);
  32.         t1.start();
  33.         t2.start();
  34.         // 下面这段代码在junit测试中是必须的,如果是在main中则没有必要
  35.         try {
  36.             // 将线程1加入到当前线程,即当前测试线程会阻塞等待线程1运行完毕
  37.             t1.join();
  38.         } catch (InterruptedException e) {
  39.             e.printStackTrace();
  40.         }
  41.     }
  • wait和notify是Object中的方法
  • wait和notify执行之前都需要获得目标对象的监视器（使用synchronized）,执行后会释放监视器.
  • wait和sleep的区别和联系:
    • 联系:两者都可以暂停线程的执行
    • 区别:
      1. sleep没有释放锁,而wait释放了锁;
      2. wait方法被调用后,线程不会自动苏醒,需要别的线程调用同一对象上的notify或notifyAll方法.而sleep执行完成后,线程会自动苏醒;
      3. 所以,wait常被用于线程之间的通信.sleep常被用于暂停执行

suspend（挂起） and resume（继续执行）

  • suspend 的线程必须等到resume才能够继续执行，另外,suspend的线程在挂起时不会释放锁资源，因此可能会造成死锁（一直占用锁资源不释放）
  • 这两个方法被废弃了
  1. @Test
  2.     public void suspendAndResume() throws InterruptedException {
  3.         Object obj = new Object();
  4.         Runnable task = () -> {
  5.             synchronized(obj){
  6.                 Thread thread = Thread.currentThread();
  7.                 System.out.println(thread.getName() + " will be suspended!");
  8.                 thread.suspend();
  9.                 System.out.println(thread.getName() + " was resumed!");
  10.             }
  11.         };
  13.         Thread t1 = new Thread(task, "task1");
  14.         t1.start();
  15.         // 如果注释掉part1则可能会造成死锁.由于resume先于suspend被调用,也就是一直处于被挂起状态
  16.         // 记为part1 >>>
  17.         try {
  18.             Thread.sleep(2000);
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  22.         // <<<
  23.         t1.resume();
  24.         t1.join();
  25.     }

join and yield

  • join是谁加入时？谁等待？
  1. public static void main(String[] args){
  2.   int count = 0;
  3.   Thread t = new Thread(
  4.     () -> {
  5.       for(int i = 0; i < 1000; i++){
  6.       count++;
  7.       }
  8.     }
  9.   );
  10.   t.join(); // 将t这一线程加入到main（当前线程），所以main线程等待t完成
  11. }

stop and interrupt

  1. stop和interrupt的不同:Thread.interrupt()被调用时不会使目标线程立即退出，只是通知目标线程中断，也就是设置中断标志位。而Thread.stop()是立即终止线程（操作过程中立即终止可能会造成数据不一致）。
  2. Thread.sleep过程如果中断会抛出异常，并且它会清除中断标志（所以如有需要应重新加上中断标志）
  3. 常用方法
  • void interrupt()
  • boolean isInterrupted() 判断是否被中断,不会清除标志位
  • static boolean interrupted() 判断是否被中断，并清除中断标志位
  1. stop方法被废弃了
  1. @Test
  2.     public void stopAndInterrupt() throws InterruptedException {
  3.         @ToString
  4.         class People {
  5.             String name = "001";
  6.             String id = "001";
  7.         }
  8.         People p1 = new People();
  9.         People p2 = new People();
  11.         Runnable t1 = () -> {
  12.             Thread thread = Thread.currentThread();
  13.             while(!thread.isInterrupted()){
  14.                 System.out.println(thread.getName());
  15.                 p1.name = "002";
  16.                 try {
  17.                     Thread.sleep(3000);
  18.                 } catch (InterruptedException e) {
  19.                     e.printStackTrace();
  20.                 }
  21.                 p1.id = "002";
  22.             }
  23.         };
  25.         Runnable t2 = () -> {
  26.             Thread thread = Thread.currentThread();
  27.             while(!thread.isInterrupted()){
  28.                 System.out.println(thread.getName());
  29.                 p2.name = "002";
  30.                 try {
  31.                     Thread.sleep(3000);
  32.                 } catch (InterruptedException e) {
  33.                     // Thread.sleep由于抛出异常它会清除中断标志，所以需要重新加上
  34.                     thread.interrupt();
  35.                 }
  36.                 p2.id = "002";
  37.             }
  38.         };
  40.         /** 使用stop暴力停止线程:数据会不一致 **/
  41.         Thread thread1 = new Thread(t1, "thread1");
  42.         thread1.start();
  43.         Thread.currentThread().sleep(1000);
  44.         thread1.stop();
  45.         System.out.println(p1);
  47.         /** 使用interrupt中断线程 **/
  48.         Thread thread2 = new Thread(t2, "thread2");
  49.         thread2.start();
  50.         Thread.currentThread().sleep(1000);
  51.         thread2.interrupt();
  52.         thread2.join(); // 必须阻塞，否则也不能获得正确的结果（因为thread2还没有修改 ）
  53.         System.out.println(p2);
  54.     }

结果

  1. thread1
  2. People(name=002, id=001)
  3. thread2
  4. People(name=002, id=002)