1.并发编程线程基础

1.1什么是线程和进程？

1. 线程是进程中的一个实体，线程本身是不会独立存在的，线程则是进程的一个执行路径
2. 进程是系统进行资源分配的基本单位，线程是CPU分配的基本单位
3. 进程例子：我们在电脑上启动的一个个应用，比如我们启动一个浏览器，就会启动了一个浏览器进程
4. 线程例子：在 Java 程序中启动的一个 main 函数，即启动了一个JVM进程，而main函数所在的线程就是这个进程中的一个线程，称为主线程

1.2线程创建与运行

1. Java中创建线程主要有三种⽅式，分别为继承Thread类、实现Runnable接口、实现Callable接口。

1.2.1继承Thread类

1. 继承Thread类，重写run()⽅法，调⽤start()⽅法启动线程

public class ThreadTest {/*** 继 承Thread类**/public static class MyThread extends Thread {@Overridepublic void run () {System.out.println( "This is child thread" ) ;}}public static void main ( String [] args) {MyThread thread = new MyThread ();thread.start();}
}

1.2.2实现Runnable接口

1. 实现 Runnable 接口，重写 run() 方法
2. 然后创建 Thread 对象，将 Runnable 对象作为参数传递给 Thread 对象，调用 start() 方法启动线程。

class RunnableTask implements Runnable {public void run() {System.out.println("上岸、上岸!");}public static void main(String[] args) {RunnableTask task = new RunnableTask();Thread thread = new Thread(task);thread.start();}
}

1.2.3实现Callable接口（与线程池搭配使用）

1. 实现 Callable 接口，重写 call() 方法
2. 然后创建 FutureTask 对象，参数为 Callable 对象；紧接着创建 Thread 对象，参数为 FutureTask 对象，调用 start() 方法启动线程。
3. 通过 实现Callable接口的对象 的get方法获取返回结果

class CallableTask implements Callable<String> {public String call() {return "上岸、上岸了!";}public static void main(String[] args) throws ExecutionException, InterruptedException {CallableTask task = new CallableTask();FutureTask<String> futureTask = new FutureTask<>(task);Thread thread = new Thread(futureTask);thread.start();System.out.println(futureTask.get());}
}

1.2.4小结

1.3线程常用方法

1. 线程等待方法：wait()、wait(long timeout)、wait(long timeout，int nanos)
2. 线程通知方法：nodify()、notifyAll()
3. 让出优先权：yield()
4. 线程中断方法：interrupt()、isinterrupted()、interrupted()
5. 线程休眠方法：sleep()

1.3.1线程等待与通知

线程等待方法：

1. wait()：当一个线程 A 调用一个共享变量的 wait() 方法时，线程 A 会被阻塞挂起，直到发生下面几种情况才会返回 ：

   1.1 线程 B 调用了共享对象 notify()或者 notifyAll() 方法；

   1.2 其他线程调用了线程 A 的 interrupt()方法，线程 A 抛出 InterruptedException 异常返回。

2. wait(long timeout) ：这个方法相比 wait() 方法多了一个超时参数，它的不同之处在于，如果线程 A 调用共享对象的 wait(long timeout)方法后，没有在指定的 timeout 时间内被其它线程唤醒，那么这个方法还是会因为超时而返回。、

3. wait(long timeout, int nanos)，其内部调用的是 wait(long timout) 方法。

唤醒/通知线程主要有下面两个方法：

1. notify()：一个线程 A 调用共享对象的 notify() 方法后，会唤醒一个在这个共享变量上调用 wait 系列方法后被挂起的线程。一个共享变量上可能会有多个线程在等待，具体唤醒哪个等待的线程是随机的。
2. notifyAll()：不同于在共享变量上调用 notify()方法会唤醒被阻塞到该共享变量上的一个线程，notifyAll 方法会唤醒所有在该共享变量上调用 wait 系列方法而被挂起的线程。

join()：等待线程执行终止

1. 如果一个线程 A 执行了 thread.join()，当前线程 A 会被阻塞，即等待 thread 线程执行终止之后才从 thread.join() 返回

1.3.2线程睡眠

1. sleep(long millis)：Thread 类中的静态方法，当一个执行中的线程 A 调用了 Thread 的 sleep 方法后，线程 A 会暂时让出指定时间的执行权。
2. 但是线程 A 所拥有的监视器资源，比如锁，还是持有不让出的。指定的睡眠时间到了后该方法会正常返回，接着参与 CPU 的调度，获取到 CPU 资源后就可以继续运行

1.3.3让出CPU执行权

1. yield()：Thread 类中的静态方法，当一个线程调用 yield 方法时，实际是在暗示线程调度器，当前线程请求让出自己的 CPU

1.3.4线程中断

1. Java 中的线程中断是一种线程间的协作模式，通过设置线程的中断标志并不能直接终止该线程的执行。

2. void interrupt()：中断线程

   2.1 例如：当线程A运行时，线程B可以调用线程A的interrupt()方法来设置线程A的中断标志为true并立即返回

   2.2 设置中断标志仅仅是标记，线程A并没有被中断，会继续往下执行

   2.3 但如果线程A因为调用wait、join、以及sleep方法而被阻塞挂起，这时线程B若调用线程A的interrupt()方法，线程A会在调用这些方法的地方抛出InterrupedException异常

3. boolean isInterrupted()：检测当前线程是否被中断，如果是返回true，否则返回false

4. boolean interrupted()：检测当前线程是否被中断，如果是返回true，否则返回false。与 isInterrupted 不同的是，该方法如果发现当前线程被中断，则会清除中断标志。

1.4理解线程上下文切换

1. 在多线程编程中，线程个数一般都大于CPU个数，但是每个CPU同一时刻只能被一个线程使用
2. 为了让用户感觉多个线程是在同时执行，CPU资源的分配采用了时间片轮转的方法，即给每个线程分配一个时间片，线程在时间片内占用CPU执行任务。当线程使用完时间片，就处于就绪状态并让出CPU让其他线程占用，即上下文切换

1.5线程死锁

1.5.1什么是线程死锁？

1. 死锁是指两个或两个以上的线程在执行过程中，因为争夺资源而造成的互相等待的现象

2. 产生死锁的四个条件：

   2.1 互斥性：资源是互斥的，同一时刻只能由一个线程占用

   2.2 请求并持有条件：一个线程已经占有一个资源，同时提出新的资源请求，并占据已有的资源不释放

   2.3 不可剥夺条件：线程获取到的资源在自己使用完之前不能被其他线程所占用

   2.4 环路等待条件：指在发生死锁时，必然存在一个线程一资源的环形链

3. 代码举例：

   import java.util.Date;public class LockTest {public static String obj1 = "obj1";public static String obj2 = "obj2";public static void main(String[] args) {LockA la = new LockA();new Thread(la).start();LockB lb = new LockB();new Thread(lb).start();}
   }
   class LockA implements Runnable{public void run() {try {System.out.println(new Date().toString() + " LockA 开始执行");while(true){synchronized (LockTest.obj1) {System.out.println(new Date().toString() + " LockA 锁住 obj1");Thread.sleep(3000); // 此处等待是给B能锁住机会synchronized (LockTest.obj2) {System.out.println(new Date().toString() + " LockA 锁住 obj2");Thread.sleep(60 * 1000); // 为测试，占用了就不放}}}} catch (Exception e) {e.printStackTrace();}}
   }
   class LockB implements Runnable{public void run() {try {System.out.println(new Date().toString() + " LockB 开始执行");while(true){synchronized (LockTest.obj2) {System.out.println(new Date().toString() + " LockB 锁住 obj2");Thread.sleep(3000); // 此处等待是给A能锁住机会synchronized (LockTest.obj1) {System.out.println(new Date().toString() + " LockB 锁住 obj1");Thread.sleep(60 * 1000); // 为测试，占用了就不放}}}} catch (Exception e) {e.printStackTrace();}}
   }
   

4. 执行结果：

   

1.5.2如何避免死锁？

1. 只要破坏产生死锁的四大条件中的一个即可，其中破坏环形等待条件最为容易，即保持资源申请的有序性就可以避免死锁

2. 例子：

   class LockB implements Runnable{public void run() {try {System.out.println(new Date().toString() + " LockB 开始执行");while(true){synchronized (LockTest.obj1) {System.out.println(new Date().toString() + " LockB 锁住 obj2");Thread.sleep(3000); synchronized (LockTest.obj2) {System.out.println(new Date().toString() + " LockB 锁住 obj1");Thread.sleep(60 * 1000); }}}} catch (Exception e) {e.printStackTrace();}}
   }