《Java语言高级特性（阿里云大学）》笔记 第1~6章 关于线程（文档+思维导图）

课程链接：https://edu.aliyun.com/course/1012

（思维导图在最后）

————————————————————————————————————

第1章：Java多线程编程

课时2：进程与线程

• 在Java语言里，最大的特点是支持多线程的开发（是为数不多，支持多线程的编程语言）。

• 在传统DOS系统的时代，如果电脑上出现了病毒，那么所有的程序将无法执行，这是因为采用的是单进程处理，而单进程处理的最大特点：在一个时间段上只允许一个程序在执行。

• 后来的windows时代，就开启了多进程的设计，在一个时间段上可以依次执行多个程序（进行资源的抢占），而一个时间点上只会有一个进程执行。

• 线程：是在进程的基础上划分的更小的程序单元，是在进程的基础上创建并使用的，依赖于进程。线程的启动速度比进程快许多，所以多线程并发处理的执行性能要高于进程。

课时3：Thread类实现多线程

• 实现多线程方式一：继承java.lang.Thread类。

• 实现步骤：

  1. 继承Thread类；
  2. 覆写Thread类的run()方法。
  3. 调用Thread类的start()方法。

• 多线程要执行的功能在run()方法中进行定义，但run()方法是不能够被直接调用的，这跟操作系统的资源调度有关。要想启动多线程，得使用start()方法。

class MyThread extends Thread { // 线程主体类
    private String title;
    public MyThread(String title) {
        this.title = title;
    }
    @Override
    public void run() { // 线程的主体方法
        for (int i = 0; i < 10; i++) {
            System.out.println(this.title + "运行，i = " + i);
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        new MyThread("线程A").start();
        new MyThread("线程B").start();
        new MyThread("线程C").start();
    }
}

调用的是start()方法，实际执行的是run()方法，最终线程会交替执行。

• 查看start()方法的源码可以发现，其又调用了start0()方法，而这个方法带有“native”修饰符，这个修饰符表示调用的是本地操作系统接口。

• 调用本地操作系统接口：JNI（Java Native Interface）技术，使用操作系统提供的底层接口。

• 任何情况下，多线程的启动永远只有一种方案：调用Thread类的start()方法。

课时4：Runnable接口实现多线程

• 实现多线程方式二：实现java.lang.Runnable接口。

• Runnable接口的定义：

  @FunctionalInterface
  public interface Runnable {
      public abstract void run();
  }
  

• 实现步骤：

  1. 实现Runnable接口；
  2. 覆写Runnable接口的run()方法。

• 分析：

  1. Runnable接口是没有start()方法的；
  2. 而观察Thread类的构造方法可以发现，其有接收Runnable参数的构造方法。

class MyThread implements Runnable { // 线程主体类
    private String title;
    public MyThread(String title) {
        this.title = title;
    }
    @Override
    public void run() { // 线程的主体方法
        for (int i = 0; i < 10; i++) {
            System.out.println(this.title + "运行，i = " + i);
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        new Thread(new MyThread("线程A")).start();
        new Thread(new MyThread("线程B")).start();
        new Thread(new MyThread("线程C")).start();
    }
}

• 使用Runnable接口来实现多线程，可以避免单继承的局限。

• 从JDK1.8之后，Runnable接口使用了函数式接口定义，所以可以直接利用Lambda表达式进行线程类的实现。

  public class ThreadDemo {
      public static void main(String[] args) {
          for (int i = 0; i < 3; i++) {
              String title = "线程" + i;
              Runnable run = ()->{
                  for (int j = 0; j < 10; j++) {
                      System.out.println(title + "运行，j = " + j);
                  }
              };
              new Thread(run).start();
          }
      }
  }
  

• 在实现多线程时，优先考虑就是利用Runnable接口，并且永恒都是通过Thread类对象来启动多线程。

课时5：Thread与Runnable关系

• Thread类是Runnable接口的子类：

  public class Thread implements Runnable
  

  所以在继承Thread类时，实际上覆写的是Runnable接口的run()方法。

多线程的设计中，使用了代理设计模式，用户自定义的线程类只是负责项目业务功能的实现，而所有具体的线程实现全部交由Thread类来处理。

• 通过Thread类构造方法传递Runnable接口对象时，该接口对象则被保存在Thread类中的target属性中，在Thread类的start()方法执行时，会调用run()方法，而run()方法又去调用了target.run()方法，也就是调用了Runnable接口子类覆写的run()方法。

  1.new Thread	→	public Thread(Runnable target)
  	this.target = target;
  2.调用start()
  	调用native start0()
  		调用run()
  			调用target.run()	→	Runnable类的run()
  

• 多线程开发的本质：多个线程进行同一资源的抢占。

• Thread类描述的是线程，Runnable接口描述的是资源。

• 案例：

  • 卖票程序

    • 代码实现：

      class MyThread implements Runnable {
          private int ticket = 5;
          @Override
          public void run() {
              for (int i = 0; i < 100; i++) {
                  if (0 < this.ticket)
                      System.out.println("卖票，ticket = " + this.ticket --);
              }
          }
      }
      public class ThreadDemo {
          public static void main(String[] args) {
              MyThread mt = new MyThread();
              new Thread(mt).start(); // 第一个线程启动
              new Thread(mt).start(); // 第二个线程启动
              new Thread(mt).start(); // 第三个线程启动
          }
      }
      

    • 内存分析：

      

课时6：Callable接口实现多线程

• 使用Runnable接口实现多线程的缺点：当线程执行完毕之后，无法获取返回值。所以从JDK1.5之后，提供了一个新的线程实现的接口：java.util.concurrent.Callable接口。

• Callable接口的定义：

  @FunctionalInterface
  public interface Callable<V> {
      V call() throws Exception;
  }
  

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

class MyThread implements Callable {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println("******** 线程执行，i = " + i);
        }
        return "线程执行完毕。";
    }
}
public class ThreadDemo {
    public static void main(String[] args) throws Exception {
        FutureTask<String> task = new FutureTask<>(new MyThread());
        new Thread(task).start();
        System.out.println("【线程返回数据】" + task.get());
    }
}

（个人分析如下：）

1.new FutureTask	→	public FutureTask(Callable<V> callable)
	this.callable = callable;
2.new Thread	→	public Thread(Runnable target)
	this.target = target;
3.调用start()
	调用native start0()
		调用run()
			调用target.run()	→	FutureTask类的run()
				result = callable.call()
				set(result)
					outcome = result	→	将call()方法的返回值放入outcome属性

1.task.get()	→	FutureTask类的get()	→	覆写Futrue类的get()
	获取outcome属性

• 面试题：请解释Runnable与Callable的区别？
  • Runnable是在JDK1.0时就提供的接口，而Callable是在JDK1.5之后才提供的。
  • Runnable接口中只有一个run()方法，并且没有返回值；而Callable接口中提供有call()方法，可以有返回值。

课时7：多线程运行状态

• 多线程开发步骤：

  1. 定义线程主体类；
  2. 通过Thread类的start()方法启动线程。

• 调用Thread类的start()方法启动线程，并不代表线程就开始运行了。

• 线程运行状态：

  

  1. 调用Thread类的start()方法后，线程会进入就绪状态；
  2. 线程等待资源调度，调度成功之后则进入运行状态（调用run()方法），但所有的线程不可能都一直持续执行下去，可能会进入阻塞状态，然后到再次被调度时则重新回归到就绪状态；
  3. 当run()方法执行完毕，则任务结束，终止。

第2章：线程常用操作方法

课时8：线程的命名和取得

• Thread类中有关线程名的方法：
  • 构造方法：public Thread(Runnable target, String name)
  • 设置线程名：public final void setName(String name)
  • 获取线程名：public final String getName()

class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        new Thread(mt, "线程A").start(); // 设置线程名