线程 – 进程
线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程线程可以拥有自己的堆栈、程序设计器、局部变量，但不拥有系统资源，与父进程的其他线程共享该进程所拥有的全部资源线程 – 线程
独立运行，它并不知道进程中是否还有其他线程存在执行是抢占式（当前运行的线程在任何时候都可能被挂起，以便另一个线程可以运行）进程
操作系统支持同时运行多个任务，每个任务（程序）就是进程处于运行过程中的程序，具有一定的独立功能（独立性、动态性、并发性）系统进行资源分配和调度的一个独立单位线程
当一个程序运行时，内部可能包含多个顺序执行流，每个顺序执行流就是一个线程单线程
程序的功能有限，不能满足不同客户端之间互不干扰的要求多线程
共享内存：进程间不能，线程间很容易效率：系统创建进程时需要为该进程重新分配系统资源，线程数据可共享（进程代码块、进程的共有数据…），因此多线程的多任务并发比多进程效率高编程难度：Java语言内置了多线程功能支持，不是单纯地作为底层操作系统的调度方式，因此简化了Java的多线程编程状态转换图 详细解释
方法：
步骤：
定义Thread类的子类，重写该类run方法创建Thread子类的实例（创建线程对象）调用线程对象的start()方法来启动该线程用到的方法：
Thread.currentThread()：返回当前正在执行的线程对象getName()：返回调用该方法的线程名字 实例： public class FirstThread extends Thread { private int i; @Override public void run() { for (; i < 100; i++) { System.out.println(getName() + "" + i); } } public static void main(String[] args) { for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + "" + i); if (i == 20) { new FirstThread().start(); new FirstThread().start(); } } } }Runnable接口是函数式接口，可使用Lambda表达式创建Runnable对象
步骤
定义Runnable接口的实现类，重写该接口run方法创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象调用线程对象的start()方法来启动该线程实例
public class SecondThread implements Runnable { private int i; @Override public void run() { for (; i < 100; i++) { System.out.println(Thread.currentThread().getName() + " " + i); } } public static void main(String[] args) { for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + " " + i); if (i == 20) { SecondThread st = new SecondThread(); new Thread(st, "新线程1").start(); new Thread(st, "新线程2").start(); } } } }Future接口来代表Callable接口里call方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现了Future接口
步骤：
定义Callable接口的实现类，重写call方法使用FutureTask类来包装Callable对象（该FutureTask对象封装了该Callable对象的call方法的返回值）调用FutureTask对象的get方法来获得子线程执行结束后的返回值实例：
public class ThirdThread { public static void main(String[] args) { FutureTask<Integer> task = new FutureTask<>((Callable<Integer>) () -> { int i = 0; for (; i < 100; i++) { System.out.println(Thread.currentThread().getName() + " " + i); } return i; }); for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + " " + i); if (i == 20) { new Thread(task, "有返回值的线程").start(); } } try { System.out.println("子线程的返回值：" + task.get()); } catch (Exception ex) { ex.printStackTrace(); } } }对比：
join 指一个线程等待另一个线程完成（当调用join方法，调用线程将被阻塞，直到join方法加入的join线程执行完为止）。常用于将大问题划分成许多小问题，每个小问题分配一个线程。当所有小问题得到处理后，再调用主进程来进一步操作。
实例
public class JoinThread extends Thread{ public JoinThread(String name){ super(name); } @Override public void run(){ for (int i = 0; i < 100; i++) { System.out.println(getName()+" "+ i ); } } public static void main(String[] args) throws InterruptedException { new JoinThread("新线程：").start(); for (int i = 0; i < 100; i++) { if (i == 20) { JoinThread jt = new JoinThread("被join的线程"); jt.start(); jt.join(); } System.out.println(Thread.currentThread().getName() + " " + i); } } }后台线程会为其他线程提供服务，比如我们常常接触到的JVM的垃圾回收线程。那么我们是怎么使用的呢？ setDaemon(true) 可以将指定线程设置成后台线程，在start方法之前调用。当所有的前台线程死亡时，后台线程随之死亡。前台线程创建的子线程默认是前台线程，后台线程则对应的是后台线程。
sleep 会暂停当前线程。暂停后，会给其他线程执行机会，不会理会优先级。而且抛出InterruptedException异常，调用sleep方法捕捉或抛出该异常。由于 sleep 具有更好的移植性，因此推荐使用。
yield 会暂停当前线程。暂停后，只会给优先级相同，或优先级更高的线程执行机会，而且没有声明抛出任何异常。
用到的方法是 setPriority。它的范围是1-10，默认5。我们需要知道子线程默认的优先级与父类相同。
为什么要有线程同步？这是因为线程调度不稳定，程序可能出现错误。
那么我们应该如何解决这一问题呢？
可以使用同步监视器（synchronized），主要用于同步代码块或者同步方法，此外，还可以用 lock。 可能产生的问题：这个时候我们就不得不考虑死锁的问题，死锁的产生是因为两个线程相互等待对方释放同步监视器，死锁的特征是一旦出现死锁，程序没有异常，没有提示，这时所有线程处于阻塞状态，无法继续。
