程序、进程、线程的理解


1.程序(program)

概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码

2.进程(process)

概念：程序的一次执行过程，或是正在运行的一个程序
说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

3.线程(thread)

概念：进程可进一步细化为线程，是一个程序内部的一条执行路径
说明：线程作为调度和执行的单位每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小

image.png

补充：
内存结构：
image.png

进程可以细化为多个线程
每个线程，拥有自己独立的：栈、程序计数器
多个线程 ，共享同一个进程中的结构：方法区、堆

并行与并发


1.单核CPU与多核CPU的理解
image.png

2.并行与并发的理解

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事
并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事


创建多线程的两种方式


方式一：继承Thread类的方式：

1.创建一个继承于Thread类的子类
2.重写Thread类的run() —> 将此线程执行的操作声明在run()中
3.创建Thread类的子类的对象
4.通过此对象调用start()：① 启动当前线程 ② 调用当前线程的run()
说明的两个问题：
问题一：我们启动一个线程，必须调用start()，不能调用run()的方式启动线程
问题二：如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start()


方式二：实现Runnable接口的方式：

1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()


两种方式对比：


开发中优先选择实现Runnable接口的方式
原因：一、实现的方式没有类的单继承性的局限
二、实现的方式更适合来处理多个线程有共享数据的情况
联系：public class Thread implements Runnable
相同点：两种方式有需要重写run()，将线程要执行的逻辑声明在run()中
目前两种方式，要想启动线程，都是调用的Thread类中的start()


Thread类中的常用方法


Thread类中的常用的方法：

1.start()：启动当前线程；调用当前线程的run()方法
2.run()：通常需要重写Thread类中此方法，将创建的线程要执行的操作声明在此方法中
3.currentThread()：静态方法，返回执行当前代码的线程
4.getName()：获取当前线程的名字
5.setName()：设置当前线程的名字
6.yield()：释放当前cpu的执行权
7.join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态
8.stop()：已过时。当执行此方法时强制结束当前线程
9.sleep(long milltime)：让当前线程“睡眠”指定milltime毫秒时间内。在指定的milltime毫秒时间内，当前线程时阻塞状态
10.isAlive()：判断当前线程是否存活

线程的优先级：

1.MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5 —> 默认的优先级
2.如何获取和设置当前线程的优先级：
getPriority()：获取线程优先级
setPriority(int p)：设置线程优先级

说明：高优先级的线程要抢占低优先级线程的cpu的执行权，但是只是概率上讲，高优先级的线程高概率的情况下被执行，并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行

线程通信：wait() / notify() / notifyAll()：此三个方法定义在Object类中的


补充：线程的分类
一种是守护线程，一种是用户线程

Thread的生命周期


图示：
image.png
说明：

1.生命周期关注两个概念：状态、相应的方法
2.关注：状态a —> 状态b：哪些方法执行了（回调方法）
某个方法主动调用：状态a —> 状态b
3.阻塞：临时状态，不可以作为最终状态
死亡：最终状态


线程的同步机制(重点)

1.背景

例子：创建三个窗口卖票，总票数为100张，使用实现Runnable接口的方式
1.问题：卖票过程中，出现了重票、错票 —> 出现了线程安全问题
2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
3.如何解决：当一个线程在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时其他线程才可以操作ticket。这种情况即使线程a出现了阻塞，也不能改变


2.Java解决方案：同步机制
在java中，我们通过同步机制，来解决线程的安全问题


方式一：同步代码块
synchronized(同步监视器){
//需要被同步的代码
}
说明：操作共享数据的代码，即为需要被同步的代码 —> 不能包含代码多了，也不能包含少了
共享数据：多个线程共同操作的变量。比如：ticket就是共享数据
同步监视器，俗称：锁。任何一个类的对象，都可以充当锁
要求：多个线程必须要共用同一把锁
补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器
在继承Tread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器

方式二：同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的
关于同步方法的总结：
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
2.非静态的同步方法，同步监视器是：this
静态的同步方法，同步监视器是：当前类本身

方式三：Lock锁 —- JDK5.0新增
1.面试题：synchronized与Lock的异同
相同：二者都可以解决线程安全问题
不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步检测器
Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

使用的优先顺序：
Lock —> 同步代码块(已经进入了方法体，分配了相应资源) —> 同步方法(在方法体外)

3.利弊

同步的方式，解决了线程的安全问题 —> 好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低 —> 局限性


4.面试题：
① Java是如何解决线程安全问题的，有几种方式？并对比几种方式的不同
② synchronized和Lock方式解决线程安全问题对比


线程安全的单例模式（懒汉式）


使用同步机制将单例模式中的懒汉式改写为线程安全的

  1. class Bank{
  2.     private Bank(){
  3.     }
  4.     private static Bank instance = null;
  6.     public static Bank getInstance(){
  7.         //方式一：效率稍差
  8. //        synchronized (Bank.class) {
  9. //            if (instance == null){
  10. //                instance = new Bank();
  11. //            }
  12. //            return instance;
  13. //        }
  14.         //方式二：效率更高
  15.         if (instance == null) {
  16.             synchronized (Bank.class) {
  17.                 if (instance == null) {
  18.                     instance = new Bank();
  19.                 }
  20.             }
  21.         }
  22.         return instance;
  23.     }
  24. }

面试题：写一个线程安全的单例模式
饿汉式
懒汉式：上面提供的


死锁问题


1.死锁的理解：

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁


2.说明：

  1. 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
  2. 我们使用同步时，要避免出现死锁


3.举例：

  1. public static void main(String[] args) {
  2.     StringBuffer s1 = new StringBuffer();
  3.     StringBuffer s2 = new StringBuffer();
  5.     new Thread(){
  6.         @Override  
  7.         public void run() {
  8.             synchronized (s1){
  9.                 s1.append("a");
  10.                 s2.append("1");
  11.                 try {
  12.                     Thread.sleep(100);
  13.                 } catch (InterruptedException e) {
  14.                     e.printStackTrace();
  15.                 }
  16.                 synchronized (s2){
  17.                     s1.append("b");
  18.                     s2.append("2");
  19.                     System.out.println(s1);
  20.                     System.out.println(s2);
  21.                 }
  22.             }
  23.         }
  24.     }.start();
  26.     new Thread(new Runnable() {
  27.         @Override  
  28.         public void run() {
  29.             synchronized (s2){
  30.                 s1.append("c");
  31.                 s2.append("3");
  32.                 try {
  33.                     Thread.sleep(100);
  34.                 } catch (InterruptedException e) {
  35.                     e.printStackTrace();
  36.                 }
  37.                 synchronized (s1){
  38.                     s1.append("d");
  39.                     s2.append("4");
  40.                     System.out.println(s1);
  41.                     System.out.println(s2);
  42.                 }
  43.             }
  44.         }
  45.     }).start();
  47. }



线程通信


1.线程通信涉及到的三个方法：

wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步检测器
notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个
notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程


2.说明：

1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中
2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常
3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中


3.面试题：
sleep()和wait()方法的异同？
1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态
2.不同点：
两个方法声明的位置不同：Thread类中声明的sleep()，Object类中声明wait()
调用的要求不同：sleep()可以在任何需要的场景下调用，wait()必须使用在同步代码块或同步方法中
关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁

  1. 小结释放锁的操作：

image.png

小结不会释放锁的操作：
image.png

JDK5.0新增线程创建方式


新增方式一：实现Callable接口 —- JDK5.0新增

  1. //1.创建一个实现Callable的实现类
  2. class NumThread implements Callable{
  3.     //2.实现call方法，将此线程需要执行的操作声明在call()中
  4.     @Override
  5.     public Object call() throws Exception {
  6.         int sum = 0;
  7.         for (int i = 0; i <= 100; i++) {
  8.             if (i % 2 == 0){
  9.                 System.out.println(i);
  10.                 sum += i;
  11.             }
  12.         }
  13.         return sum;
  14.     }
  15. }
  17. public class ThreadNew {
  18.     public static void main(String[] args) {
  19.         //3.创建Callable接口实现类的对象
  20.         NumThread numThread = new NumThread();
  22.         //4.将此Callable接口实现类的对象传递到FutureTask构造器中，创建FutureTask对象
  23.         FutureTask futureTask = new FutureTask(numThread);
  25.         //将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
  26.         new Thread(futureTask).start();
  28.         try {
  29.             //6.获取Callable中的call方法返回值
  30.             //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
  31.             Object sum = futureTask.get();
  32.             System.out.println("总和为：" + sum);
  33.         } catch (InterruptedException e) {
  34.             e.printStackTrace();
  35.         } catch (ExecutionException e) {
  36.             e.printStackTrace();
  37.         }
  39.     }
  40. }


说明：

如何理解实现Callable接口的方式创建多线程比实现Runnable接口的方式创建多线程更强大？
1.call()可以有返回值
2.call()可以抛出异常，被外面的操作捕获，获取异常的信息
3.Callable是支持泛型的


新增方式二：使用线程池

  1. class NumberThread implements Runnable{
  2.     @Override
  3.     public void run() {
  4.         for (int i = 0; i <= 100; i++) {
  5.             if (i % 2 == 0) {
  6.                 System.out.println(Thread.currentThread().getName() + "：" + i);
  7.             }
  8.         }
  9.     }
  10. }
  12. class NumberThread1 implements Runnable{
  13.     @Override
  14.     public void run() {
  15.         for (int i = 0; i <= 100; i++) {
  16.             if (i % 2 != 0) {
  17.                 System.out.println(Thread.currentThread().getName() + "：" + i);
  18.             }
  19.         }
  20.     }
  21. }
  23. public class ThreadPool {
  24.     public static void main(String[] args) {
  25.         //1.提供指定线程数量的线程池
  26.         ExecutorService service = Executors.newFixedThreadPool(10);
  27.         ThreadPoolExecutor service1 = (ThreadPoolExecutor)service;
  29.         //设置线程池的属性
  30. //        System.out.println(service.getClass());
  31. //        service1.setCorePoolSize(15);
  33.         //2.执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
  34.         service.execute(new NumberThread());//适合使用于Runnable
  35.         service.execute(new NumberThread1());//适合使用于Runnable
  37. //        service.submit(Callable callable);//适合使用于Callable
  38.         //3.关闭连接池
  39.         service.shutdown();
  40.     }
  41. }


说明：

好处：
1.提高响应速度（减少了创建新线程的时间）
2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3.便于线池管理
corePoolSize：核心池大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间会终止


面试题：Java中多线程的创建有几种方式？四种