[TOC] # 简介 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。 简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程 * 程序运行原理 - 分时调度 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。 - 抢占式调度 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。 # Thread类 Thread是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。  * 构造方法 ~~~ Thread() 分配新的Thread对象 Thread(String name) 分配新的Thread对象.将指定的name作为其线程名称 ~~~ * 常用方法 ~~~ void start() 使该线程开始执行,java虚拟机调用该线程的run方法 void run() 该线程要执行的操作 static void sleep(long millis) 在定义的毫秒数内让当前正在执行的线程休眠(暂停执行) ~~~ 创建新执行线程有两种方法。 * 一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。创建对象，开启线程。run方法相当于其他线程的main方法。 * 另一种方法是声明一个实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。 # 创建线程一 ## 继承Thread类 创建线程的步骤： 1. 定义一个类继承Thread。 2. 重写run方法。 3. 创建子类对象，就是创建线程对象。 4. 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。 * 测试类 ~~~ public class Demo01 { public static void main(String[] args) { //创建自定义线程对象 MyThread mt = new MyThread("新的线程！"); //开启新线程 mt.start(); //在主方法中执行for循环 for (int i = 0; i < 10; i++) { System.out.println("main线程！"+i); } } } ~~~ * 自定义线程类 ~~~ public class MyThread extends Thread { //定义指定线程名称的构造方法 public MyThread(String name) { //调用父类的String参数的构造方法，指定线程的名称 super(name); } /* * 重写run方法，完成该线程执行的逻辑 */ @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(getName()+"：正在执行！"+i); } } } ~~~ 思考：线程对象调用 run方法和调用start方法区别？ 线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。 ### 原理 * 继承Thread类原理 我们为什么要继承Thread类，并调用其的start方法才能开启线程呢？ 继承Thread类：因为Thread类用来描述线程，具备线程应该有功能。那为什么不直接创建Thread类的对象呢？如下代码： ~~~ Thread t1 = new Thread(); ~~~ t1.start();//这样做没有错，但是该start调用的是Thread类中的run方法，而这个run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让线程执行的代码。 创建线程的目的是什么？ 是为了建立程序单独的执行路径，让多部分代码实现同时执行。也就是说线程创建并执行需要给定线程要执行的任务。 对于之前所讲的主线程，它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。 Thread类run方法中的任务并不是我们所需要的，只有重写这个run方法。既然Thread类已经定义了线程任务的编写位置（run方法），那么只要在编写位置（run方法）中定义任务代码即可。所以进行了重写run方法动作。 ### 获取线程名称 开启的线程都会有自己的独立运行栈内存，那么这些运行的线程的名字是什么呢？该如何获取呢？既然是线程的名字，按照面向对象的特点，是哪个对象的属性和谁的功能，那么我们就去找那个对象就可以了。查阅Thread类的API文档发现有个方法是获取当前正在运行的线程对象。还有个方法是获取当前线程对象的名称。既然找到了，我们就可以试试。 ~~~ static Thread currentThread() 返回对当前正在执行的线程对象的引用 String getName() 返回该线程的名称 ~~~ * Thread.currentThread()获取当前线程对象 * Thread.currentThread().getName();获取当前线程对象的名称 ~~~ class MyThread extends Thread { //继承Thread MyThread(String name){ super(name); } //复写其中的run方法 public void run(){ for (int i=1;i<=20 ;i++ ){ System.out.println(Thread.currentThread().getName()+",i="+i); } } } class ThreadDemo { public static void main(String[] args) { //创建两个线程任务 MyThread d = new MyThread(); MyThread d2 = new MyThread(); d.run();//没有开启新线程, 在主线程调用run方法 d2.start();//开启一个新线程，新线程调用run方法 } } ~~~ 通过结果观察，原来主线程的名称：main；自定义的线程：Thread-0，线程多个时，数字顺延。如Thread-1...... 进行多线程编程时，不要忘记了Java程序运行是从主线程开始，main方法就是主线程的线程执行内容。 # 创建线程二 ## 实现Runnable接口 创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。  **接口中的方法** ~~~ void run() 使用实现接口Runnable的对象创建一个线程时,启动该线程将导致在独立执行的线程中调用对象的run方法 ~~~ **Thread类构造方法** ~~~ Thread(Runnable target) 分配新的Thread对象,以便将target作为其运行对象 Thread(Runnable target, String name) 分配新的对象,以便将targe作为其运行对象,将指定name作为其名称 ~~~ ## 步骤 创建线程的步骤。 1. 定义类实现Runnable接口。 2. 覆盖接口中的run方法。。 3. 创建Thread类的对象 4. 将Runnable接口的子类对象作为参数传递给Thread类的构造函数。 5. 调用Thread类的start方法开启线程 * 代码演示： ~~~ public class Demo02 { public static void main(String[] args) { //创建线程执行目标类对象 Runnable runn = new MyRunnable(); //将Runnable接口的子类对象作为参数传递给Thread类的构造函数 Thread thread = new Thread(runn); Thread thread2 = new Thread(runn); //开启线程 thread.start(); thread2.start(); for (int i = 0; i < 10; i++) { System.out.println("main线程：正在执行！"+i); } } } ~~~ * 自定义线程执行任务类 ~~~ public class MyRunnable implements Runnable{ //定义线程要执行的run方法逻辑 @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println("我的线程：正在执行！"+i); } } } ~~~ ## 原理 实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。 创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。 ## 好处 实现Runnable接口避免了单继承的局限性，所以较为常用。 实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。 # 创建线程三 ## 实现Callable接口 使用Runnable接口实现的多线程可以避免单继承局限,但是他不能返回结果. 为了解决这个,提供了一个新的接口java.util.concurrent.Callable ~~~ @FunctionalInterface public interface Callable<V> { V call() throws Exception; } ~~~ call()方法执行完线程的主题功能之后可以返回一个结果,而返回结果的类型由Callable的泛型决定 ## 步骤 实现Callable接口 Thread类里面没有发现并没有直接支持Callable接口的多线程应用 从jdk1.5开始提供有`java.util.concurrent.FutureTask<V>`类,这个类主要负责Callable ~~~ public class FutureTask<V> extends Object implement RunnableFuture<V> ~~~ 发现他实现了RunnableFuture ~~~ public interface RunnableFuture<V> extends Runnable, Future<V> ~~~ 然后我们看,在FutureTask类里面定义有如下结构的构造方法: ~~~ public FutureTask(Callable<V> callable) ~~~ 接收的目的只有一个,那么取得call()方法的返回结果 FutureTask是Runnable接口的子类,所以可以使用Thread类的构造来接收task对象 多线程执行完毕可以取得内容,依靠FutureTask的父接口Future中的get()方法完成 ## 例子 ~~~ package com.study; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; class MyThread implements Callable<String> { private int ticket = 10; @Override public String call() throws Exception { for (int i = 0; i < 100; i++) { if (this.ticket > 0) { System.out.println("卖票--- " + this.ticket--); } } return "卖光了"; } } public class HelloWorld { public static void main(String[] args) throws ExecutionException, InterruptedException { MyThread m1 = new MyThread(); MyThread m2 = new MyThread(); //目的为了取得线程的返回值,String是泛型,对应返回类型 FutureTask<String> task1 = new FutureTask<>(m1); FutureTask<String> task2 = new FutureTask<>(m2); //FutureTask是Runnable接口的子类,所以可以使用Thread类的构造来接收task对象 //启动多线程 new Thread(task1).start(); new Thread(task2).start(); //多线程执行完毕可以取得内容,依靠FutureTask的父接口Future中的get()方法完成 System.out.println("A线程返回结果: "+ task1.get()); System.out.println("B线程返回结果: "+ task2.get()); } } ~~~ # 线程的匿名内部类使用 使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。 * 方式1：创建线程对象时，直接重写Thread类中的run方法 ~~~ new Thread() { public void run() { for (int x = 0; x < 40; x++) { System.out.println(Thread.currentThread().getName() + "...X...." + x); } } }.start(); ~~~ * 方式2：使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法 ~~~ Runnable r = new Runnable() { public void run() { for (int x = 0; x < 40; x++) { System.out.println(Thread.currentThread().getName() + "...Y...." + x); } } }; new Thread(r).start(); ~~~ # 查看源码 首先方法在Thread类的start()方法里面存放有一个IllegalThreadStateException,按道理应该使用try...catch处理.或者在start()方法声明上这样的异常代码,因为此异常属于RuntimeException的子类.属于选择性处理.如果对一个线程对象重复启动,那么就会抛异常 发现在start()方法里面要调用一个start0()方法,而且此方法的结构和抽象方法类似. 开发里面有一门技术叫做JNI技术(java Native Interface)这门技术的特点:是使用java调用本机操作系统提供的函数 但是这样的技术有一个特点,不能离开特定的操作系统