1. 进程与线程的区别
进程：是系统进行分配和管理资源的基本单位
线程：进程的一个执行单元，是进程内调度的实体、是CPU调度和分派的基本单位，是比进程更小的独立运
行的基本单位。线程也被称为轻量级进程,线程是程序执行的最小单位。
一个程序至少一个进程，一个进程至少一个线程。
进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈
段和数据段，这种操作非常昂贵。 而线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个
线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多。 线程之间的通信更方便，同一 进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式进行。 如何处理好同步 与互斥是编写多线程程序的难点。 多进程程序更健壮，进程有独立的地址空间，一个进程崩溃后，在保护模 式下不会对其它进程产生影响， 而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但 线程之间没有单独的地址空间，所以可能一个线程出现问题，进而导致整个程序出现问题
2.线程的状态及其相互转换
初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
运行(RUNNABLE):处于可运行状态的线程正在JVM中执行，但它可能正在等待来自操作系统的其他资源，例 如处理器。 阻塞(BLOCKED)：线程阻塞于synchronized锁，等待获取synchronized锁的状态。 等待(WAITING)：Object.wait()、join()、 LockSupport.park(),进入该状态的线程需要等待其他线程做出一些特 定动作（通知或中断）。 超时等待(TIME_WAITING)：Object.wait(long)、Thread.join()、LockSupport.parkNanos()、 LockSupport.parkUntil，该状态不同于WAITING，它可以在指定的时间内自行返回。 终止(TERMINATED)：表示该线程已经执行完毕。2.1创建线程的方式（上）
继承Thread，并重写父类的run方法
实现Runable接口，并实现run方法 实际开发中，选第2种：java只允许单继承 增加程序的健壮性，代码可以共享，代码跟数据独立2.2创建线程的方式（下）
使用匿名内部类
Lambda表达式 线程池线程阻塞Demo:
public class ThreadStateDemo { public static void main(String[] args) throws InterruptedException { /** * Block */// Object obj = new Object();// Thread thread = new Thread(()->{//// synchronized (obj){//// try {// Thread.sleep(100000000L);// } catch (InterruptedException e) {// e.printStackTrace();// }// }//// });//// thread.start();//// Thread.sleep(2000L);//// Thread thread2 = new Thread(()->{//// synchronized (obj){//// }//// });// thread2.start();//// }/** * waiting */ Object obj = new Object(); Thread thread = new Thread(() -> { synchronized (obj) { try { obj.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } }); thread.start(); }} 线程池开启单线程:
public class ThreadPool { public static void main(String[] args) { ExecutorService executorService = Executors.newSingleThreadExecutor(); executorService.execute(() -> { System.out.println(Thread.currentThread().getName()); }); }} 相应的图示如下:
3.线程的挂起跟恢复
什么是挂起线程？ 线程的挂起操作实质上就是使线程进入“非可执行”状态下，在这个状态下CPU不会分给线程
时间片，进入这个状态可以用来暂停一个线程的运行。 在线程挂起后，可以通过重新唤醒线程来使之恢复运 行3.1 为什么要挂起线程？
cpu分配的时间片非常短、同时也非常珍贵。避免资源的浪费。
如何挂起线程？被废弃的方法 thread.suspend() 该方法不会释放线程所占用的资源。如果使用该方法将某个线程挂起，则可
能会使其他等待资源的线程死锁 thread.resume() 方法本身并无问题，但是不能独立于suspend()方法存在
可以使用的方法 wait() 暂停执行、放弃已经获得的锁、进入等待状态
notify() 随机唤醒一个在等待锁的线程
notifyAll() 唤醒所有在等待锁的线程，自行抢占cpu资源
被废弃的相关挂起Demo:
/** * 挂起操作的Demo */public class SuspendDemo implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()+"进入Run()方法,准备调用SusPend"); Thread.currentThread().suspend(); //执行挂起 System.out.println(Thread.currentThread().getName()+"进入Run()方法,调用SusPend结束"); } public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(new SuspendDemo()); thread.start(); Thread.sleep(3000L); thread.resume(); //执行恢复 }} 这里要注意的是挂起的操作是不安全的,被废弃也是因为因为他容易造成长时间阻塞:
这里阻塞的原因是因为他在挂起前就进行来了唤醒的操作,导致后来的线程一直挂起(未睡眠导致唤醒的代码提前于挂起执行了)
** * suspend死锁演示 */public class DeadDemo implements Runnable{ private static final Object object =new Object(); @Override public void run() { //持有资源 synchronized (object){ System.out.println(Thread.currentThread().getName()+"占用资源"); Thread.currentThread().suspend(); } System.out.println(Thread.currentThread().getName()+"释放资源"); } public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(new DeadDemo(),"对比线程"); thread.start(); thread.sleep(1000L); thread.resume(); Thread deadThread = new Thread(new DeadDemo(),"死锁线程"); deadThread.start();// deadThread.sleep(3000L); deadThread.resume(); }} 使用推荐的wait和notify方法操作:
package xianchengxuexi.chapter02.hang;import com.sun.jndi.toolkit.ctx.StringHeadTail;/** * 等待方法 */public class WaitDemo implements Runnable { private static Object object = new Object(); private static Object waitObj = new Object(); @Override public void run() { //持有资源 //锁住的和wait()的需要时同一个对象 synchronized (waitObj){ System.out.println(Thread.currentThread().getName()+"占用资源"); try { waitObj.wait();//这个会释放锁 } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(Thread.currentThread().getName()+"释放资源"); } public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(new WaitDemo(),"对比线程"); thread.start(); Thread thread2 = new Thread(new DeadDemo(),"对比线程2"); thread2.start(); thread.sleep(3000L); synchronized (waitObj){ waitObj.notify(); } }} 3.2 什么时候适合使用挂起线程？
我等的船还不来(等待某些未就绪的资源)，我等的人还不明白。直到notify方法被调用
3.3线程的中断操作
stop() 废弃方法，开发中不要使用。因为一调用，线程就立刻停止，此时有可能引发相应的线程安全性问题
/** * 不安全的stop */public class UnSafeWithStop extends Thread { private int a =0; private int b =0; @Override public void run() { a++; try { sleep(2000L); } catch (InterruptedException e) { e.printStackTrace(); } b++; } public void printf(){ System.out.println("a的值=======>"+a); System.out.println("b的值=======>"+b); } public static void main(String[] args) throws InterruptedException { UnSafeWithStop unSafeWithStop = new UnSafeWithStop(); unSafeWithStop.start(); Thread.sleep(1000L); unSafeWithStop.stop(); unSafeWithStop.printf(); }} Thread.interrupt方法
/** * 使用Interrupt终止线程 */public class InterruptDemo implements Runnable { @Override public void run() { while (!Thread.currentThread().isInterrupted()){ System.out.println(Thread.currentThread().getName()); } } public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(new InterruptDemo()); thread.start(); thread.sleep(1000L); thread.interrupt(); }} 自行定义一个标志，用来判断是否继续执行
/** * 自定义线程终止 */public class MyInterruptDemo implements Runnable{ private static volatile boolean FLAG = true; @Override public void run() { while (FLAG){ System.out.println(Thread.currentThread().getName()); } } public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(new MyInterruptDemo()); thread.start(); Thread.sleep(1000L); FLAG=false; }} 4.线程的优先级
线程的优先级告诉程序该线程的重要程度有多大。如果有大量线程都被堵塞，都在等候运行，程序会尽可能地先运行优先级的那个线程。
但是，这并不表示优先级较低的线程不会运行。若线程的优先级较低，只不过表示它被准许运行的机会小一些而已。
线程的优先级设置可以为1-10的任一数值，Thread类中定义了三个线程优先级，分别是： MIN_PRIORITY（1）、NORM_PRIORITY（5）、MAX_PRIORITY（10）， 一般情况下推荐使用这几个常量，不要自行设置数值。
/** * 线程优先级Demo */public class ProrityDemo { public static void main(String[] args) { Thread thread = new Thread(() -> { while (true){ System.out.println(Thread.currentThread().getName()); } },"线程1"); Thread thread2 = new Thread(() -> { while (true){ System.out.println(Thread.currentThread().getName()); } },"线程2"); thread.setPriority(Thread.MIN_PRIORITY); thread2.setPriority(Thread.MAX_PRIORITY); thread.start(); thread2.start(); }} 不同平台，对线程的优先级的支持不同。 编程的时候，不要过度依赖线程优先级，如果你的程序运行是否正
确取决于你设置的优先级是否按所设置的优先级运行，那这样的程序不正确 任务： 快速处理：设置高的优先级 慢慢处理：设置低的优先级5.守护线程
线程分类
用户线程、守护线程 守护线程：任何一个守护线程都是整个程序中所有用户线程的守护者，只要有活着的用 户线程，守护线程就活着。当JVM实例中最后一个非守护线程结束时，也随JVM一起退出 守护线程的用处：jvm垃圾清理线程 建议： 尽量少使用守护线程，因其不可控不要在守护线程里去进行读写操作、执行计算逻辑/** * 守护线程Demo */public class DaemonThreadDemo implements Runnable{ @Override public void run() { while (true) { System.out.println(Thread.currentThread().getName()); try { Thread.sleep(1000L); } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(new DaemonThreadDemo()); thread.start(); thread.setDaemon(true); Thread.sleep(2000L); }}