线程基础知识归纳

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:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

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(); } }

线程池开启单线程:

1 2 3 4 5 6 7 8

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:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

/** * 挂起操作的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(); //执行恢复 } }

这里要注意的是挂起的操作是不安全的,被废弃也是因为因为他容易造成长时间阻塞:

这里阻塞的原因是因为他在挂起前就进行来了唤醒的操作,导致后来的线程一直挂起(未睡眠导致唤醒的代码提前于挂起执行了)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

** * 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方法操作:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

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() 废弃方法，开发中不要使用。因为一调用，线程就立刻停止，此时有可能引发相应的线程安全性问题

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

/** * 不安全的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方法

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

/** * 使用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(); } }

自行定义一个标志，用来判断是否继续执行

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

/** * 自定义线程终止 */ 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），

​ 一般情况下推荐使用这几个常量，不要自行设置数值。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

/** * 线程优先级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垃圾清理线程 建议： 尽量少使用守护线程，因其不可控不要在守护线程里去进行读写操作、执行计算逻辑

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

/** * 守护线程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); } }